goliath 0.9.4 → 1.0.0.beta.1

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

@@ -0,0 +1,443 @@
+require 'spec_helper'
+require 'goliath/rack/validation/param'
+
+describe Goliath::Rack::Validation::Param do
+  before do
+    @app = mock('app').as_null_object
+    @env = {'params' => {}}
+  end
+
+  it "should not allow invalid options" do
+    lambda {
+      Goliath::Rack::Validation::Param.new(@app, {:key => 'user', :as => Class.new})
+    }.should raise_error
+  end
+
+  it "raises if key is not supplied" do
+    lambda {
+      Goliath::Rack::Validation::Param.new(@app)
+    }.should raise_error(Exception)
+  end
+
+  it "uses a default value if optional is not supplied" do
+    cv = Goliath::Rack::Validation::Param.new(@app, :key => 'key')
+    cv.optional.should be_false
+  end
+
+  it "should have default and message be optional" do
+    cv = nil
+    lambda {
+      cv = Goliath::Rack::Validation::Param.new(@app, {:key => 'flag',
+          :as => Goliath::Rack::Types::Boolean})
+    }.should_not raise_error
+
+    cv.default.should be_nil
+    cv.message.should_not be_nil
+  end
+
+  it "should fail if given an invalid option" do
+    cv = nil
+    lambda {
+      cv = Goliath::Rack::Validation::Param.new(@app, {:key => 'flag',
+          :as => Goliath::Rack::Types::Boolean, :animal => :monkey})
+    }.should raise_error
+  end
+
+  context "fetch_key" do
+    before do
+      @cv = Goliath::Rack::Validation::Param.new(@app,
+          :key => ['data', 'credentials', 'login'])
+    end
+
+    it "should return a valid value given the correct params" do
+      params = {
+        'data' => {
+          'credentials' => {
+            'login' => "mike"
+          }
+        }
+      }
+      @cv.fetch_key(params).should == "mike"
+    end
+
+    it "should return nil given an incorrect params" do
+      params = {
+        'data' => {
+          'credentials' => {
+            'login2' => "mike"
+          }
+        }
+      }
+      @cv.fetch_key(params).should be_nil
+    end
+
+    it "should set value if given" do
+      params = {
+        'data' => {
+          'credentials' => {
+            'login' => "mike"
+          }
+        }
+      }
+      @cv.fetch_key(params, "tim").should == "tim"
+      params['data']['credentials']['login'].should == "tim"
+    end
+  end
+
+  context "Required" do
+
+    it 'defaults type and message' do
+      @rp = Goliath::Rack::Validation::Param.new('app', :key => 'key')
+      @rp.type.should_not be_nil
+      @rp.type.should_not =~ /^\s*$/
+      @rp.message.should == 'identifier missing'
+    end
+
+
+    context 'with middleware' do
+      before(:each) do
+        @app = mock('app').as_null_object
+        @env = {'params' => {}}
+        @rp = Goliath::Rack::Validation::Param.new(@app, {:type => 'Monkey',
+            :key => 'mk', :message => 'is required'})
+      end
+
+      it 'stores type and key options' do
+        @rp.type.should == 'Monkey'
+        @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'}
+        @app.should_receive(:call).and_return([201, app_headers, app_body])
+
+        @env['params']['mk'] = 'monkey'
+
+        status, headers, body = @rp.call(@env)
+        status.should == 201
+        headers.should == app_headers
+        body.should == app_body
+      end
+
+      context 'key_valid?' do
+        it 'raises exception if the key is not provided' do
+          @rp.key_valid?(@env['params']).should be_false
+        end
+
+        it 'raises exception if the key is blank' do
+          @env['params']['mk'] = ''
+          @rp.key_valid?(@env['params']).should be_false
+        end
+
+        it 'raises exception if the key is nil' do
+          @env['params']['mk'] = nil
+          @rp.key_valid?(@env['params']).should be_false
+        end
+
+        it 'handles an empty array' do
+          @env['params']['mk'] = []
+          @rp.key_valid?(@env['params']).should be_false
+        end
+
+        it 'handles an array of nils' do
+          @env['params']['mk'] = [nil, nil, nil]
+          @rp.key_valid?(@env['params']).should be_false
+        end
+
+        it 'handles an array of blanks' do
+          @env['params']['mk'] = ['', '', '']
+          @rp.key_valid?(@env['params']).should be_false
+        end
+
+        it "doesn't raise if the key provided" do
+          @env['params']['mk'] = 'my value'
+          @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]
+          @rp.key_valid?(@env['params']).should be_true
+        end
+
+        it "doesn't raise if the key provided is multiline and has blanks" do
+          @env['params']['mk'] = "my\n  \nvalue"
+          @rp.key_valid?(@env['params']).should be_true
+        end
+
+        it "doesn't raise if the key provided is an array and contains multiline with blanks" do
+          @env['params']['mk'] = ["my\n  \nvalue", "my\n  \nother\n  \nvalue"]
+          @rp.key_valid?(@env['params']).should be_true
+        end
+      end
+    end
+
+    context 'Nested keys tests' do
+      before do
+        @app = mock('app').as_null_object
+        @env = {'params' => {}}
+        @rp = Goliath::Rack::Validation::Param.new(@app, :type => 'Monkey',
+            :key => ['data', 'credentials', 'login'],
+            :message => 'is required')
+      end
+
+      it "return false if key's missing" do
+        @env['params'] = {'data' => {
+          'credentials' => {
+          'login2' => "user",
+          'pass' => "password"}
+        }
+        }
+
+        @rp.key_valid?(@env['params']).should be_false
+      end
+
+      it "return true if key is present" do
+        @env['params'] = {'data' => {
+          'credentials' => {
+          'login' => "user",
+          'pass' => "password"}
+        }
+        }
+
+        @rp.key_valid?(@env['params']).should be_true
+      end
+    end
+
+    context 'Nested keys tests (with string)' do
+      before do
+        @app = mock('app').as_null_object
+        @env = {'params' => {}}
+        @rp = Goliath::Rack::Validation::Param.new(@app, :type => 'Monkey',
+            :key => 'data.credentials.login', :message => 'is required')
+      end
+
+      it "return false if key's missing" do
+        @env['params'] = {'data' => {
+          'credentials' => {
+          'login2' => "user",
+          'pass' => "password"}
+        }
+        }
+
+        @rp.key_valid?(@env['params']).should be_false
+      end
+
+      it "return true if key is present" do
+        @env['params'] = {'data' => {
+          'credentials' => {
+          'login' => "user",
+          'pass' => "password"}
+        }
+        }
+
+        @rp.key_valid?(@env['params']).should be_true
+      end
+    end
+
+  end
+
+  context "Coerce" do
+
+    it "should only accept a class in the :as" do
+      lambda {
+        Goliath::Rack::Validation::Param.new(@app, {:key => 'user', :as => "not a class"})
+      }.should raise_error
+    end
+
+    context 'with middleware' do
+      {
+        Goliath::Rack::Types::Boolean => [['t', true], ['true', true], ['f', false],
+                                           ['false', false], ['1', true],
+                                           ['0', false], ['TRUE', true],  ['FALSE', false],
+                                           ['T', true], ['F', false]
+      ],
+        Goliath::Rack::Types::Integer => [['24', 24]],
+        Goliath::Rack::Types::Float => [['24.3', 24.3]],
+        Goliath::Rack::Types::Symbol => [['hi', :hi]],
+      }.each do |type, values|
+        values.each do |value|
+          it "should coerce #{type} from #{value.first} to #{value[1]}" do
+            @env['params']['user'] = value.first
+            cv = Goliath::Rack::Validation::Param.new(@app, {:key => 'user', :as => type})
+            cv.call(@env)
+            @env['params']['user'].should == value[1]
+          end
+        end
+      end
+
+      {
+        Goliath::Rack::Types::Boolean => ["235", "hi", "3"],
+        Goliath::Rack::Types::Integer => ["hi", "false", "true"],
+        Goliath::Rack::Types::Symbol => [nil],
+        Goliath::Rack::Types::Float => [nil],
+      }.each do |type, values|
+        values.each do |value|
+          it "should not coerce #{type} with #{value}" do
+            @env['params']['user'] = value
+            cv = Goliath::Rack::Validation::Param.new(@app, {:key => 'user', :as => type})
+            result = cv.call(@env)
+            result.should be_an_instance_of(Array)
+            result.first.should == 400
+            result.last.should have_key(:error)
+          end
+        end
+      end
+
+      it "should not fail with a invalid input, given a default value" do
+        cv = nil
+        @env['params']['user'] = "boo"
+        lambda {
+          cv = Goliath::Rack::Validation::Param.new(@app, {:key => 'user',
+              :as => Goliath::Rack::Types::Boolean , :default => 'default'})
+        }.should_not raise_error
+          @env['params']['user'] = 'default'
+      end
+
+      it "should be able to take a custom fail message" do
+        @env['params']['user'] = "boo"
+        cv = Goliath::Rack::Validation::Param.new(@app, {:key => 'user',
+            :as => Goliath::Rack::Types::Integer, :message => "custom message"})
+
+        result = cv.call(@env)
+        result.should be_an_instance_of(Array)
+        result.first.should == 400
+        result.last.should have_key(:error)
+        result.last[:error].should == "custom message"
+      end
+    end
+
+  end
+
+  context "Integration" do
+    it "should do required param + coerce (not nested)" do
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login",
+          :as => Goliath::Rack::Types::Integer
+      @env['params']['login'] = "3"
+      cv.call(@env)
+      @env['params']['login'].should == 3
+
+      @env['params']['login'] = nil
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login",
+          :as => Goliath::Rack::Types::Integer
+      result = cv.call(@env)
+      result.should be_an_instance_of(Array)
+      result.first.should == 400
+      result.last.should have_key(:error)
+    end
+
+    it "should do required param + coerce (nested)" do
+      cv = Goliath::Rack::Validation::Param.new @app, :key => ['login', 'other'],
+          :as => Goliath::Rack::Types::Integer
+      @env['params']['login'] = {}
+      @env['params']['login']['other'] = "3"
+      cv.call(@env)
+      @env['params']['login']['other'].should == 3
+
+      @env['params']['login'] = {}
+      @env['params']['login']['other'] = nil
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login.other",
+          :as => Goliath::Rack::Types::Integer
+      result = cv.call(@env)
+      result.should be_an_instance_of(Array)
+      result.first.should == 400
+      result.last.should have_key(:error)
+    end
+
+    it "should do required param + not coerce (not nested)" do
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login"
+      @env['params']['login'] = "3"
+      cv.call(@env)
+      @env['params']['login'].should == "3"
+
+      @env['params']['login'] = nil
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login"
+      result = cv.call(@env)
+      result.should be_an_instance_of(Array)
+      result.first.should == 400
+      result.last.should have_key(:error)
+    end
+
+    it "should do required param + not coerce (nested)" do
+      cv = Goliath::Rack::Validation::Param.new @app, :key => ['login', 'other']
+      @env['params']['login'] = {}
+      @env['params']['login']['other'] = "3"
+      cv.call(@env)
+      @env['params']['login']['other'].should == "3"
+
+      @env['params']['login'] = {}
+      @env['params']['login']['other'] = nil
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login.other"
+      result = cv.call(@env)
+      result.should be_an_instance_of(Array)
+      result.first.should == 400
+      result.last.should have_key(:error)
+    end
+
+    it "should do optional param + coerce (not nested)" do
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login",
+          :as => Goliath::Rack::Types::Integer, :optional => true
+      @env['params']['login'] = "3"
+      cv.call(@env)
+      @env['params']['login'].should == 3
+
+      @env['params']['login'] = nil
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login",
+          :as => Goliath::Rack::Types::Integer, :optional => true
+      result = cv.call(@env)
+      result.should_not be_an_instance_of(Array) #implying its OK
+    end
+
+    it "should do optional param + coerce (nested)" do
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login.other",
+          :as => Goliath::Rack::Types::Integer, :optional => true
+      @env['params']['login'] = {}
+      @env['params']['login']['other'] = "3"
+      cv.call(@env)
+      @env['params']['login']['other'].should == 3
+
+      @env['params']['login'] = {}
+      @env['params']['login']['other'] = nil
+      cv = Goliath::Rack::Validation::Param.new @app, :key => ['login', 'other'],
+          :as => Goliath::Rack::Types::Integer, :optional => true
+      result = cv.call(@env)
+      result.should_not be_an_instance_of(Array) #implying its OK
+    end
+
+    it "should do optional param and not coerce (not nested)" do
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login",
+          :optional => true
+      @env['params']['login'] = "3"
+      cv.call(@env)
+      @env['params']['login'].should == "3"
+
+      @env['params']['login'] = nil
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login",
+          :optional => true
+      result = cv.call(@env)
+      result.should_not be_an_instance_of(Array) #implying its OK
+    end
+
+    it "should do optional param and not coerce (nested)" do
+      cv = Goliath::Rack::Validation::Param.new @app, :key => ['login', 'other'],
+          :optional => true
+      @env['params']['login'] = {}
+      @env['params']['login']['other'] = "3"
+      cv.call(@env)
+      @env['params']['login']['other'].should == "3"
+
+      @env['params']['login'] = {}
+      @env['params']['login']['other'] = nil
+      cv = Goliath::Rack::Validation::Param.new @app, :key => "login.other",
+          :optional => true
+      result = cv.call(@env)
+      result.should_not be_an_instance_of(Array) #implying its OK
+    end
+  end
+end
+

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

@@ -44,4 +44,9 @@ describe Goliath::Rack::Validation::RequestMethod do
     rm = Goliath::Rack::Validation::RequestMethod.new('my app', ['GET', 'DELETE', 'HEAD'])
     rm.methods.should == ['GET', 'DELETE', 'HEAD']
   end
+  
+  it 'accepts string method on initialize' do
+    rm = Goliath::Rack::Validation::RequestMethod.new('my app', 'GET')
+    rm.methods.should == ['GET']
+  end
 end

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

@@ -100,7 +100,77 @@ describe Goliath::Rack::Validation::RequiredParam do
       it "doesn't raise if the key provided is an array and contains multiline with blanks" do
         @env['params']['mk'] = ["my\n  \nvalue", "my\n  \nother\n  \nvalue"]
         @rp.key_valid?(@env['params']).should be_true
-      end
+      end      
+    end
+  end
+  
+  describe 'Nested keys tests' do
+    before do
+      @app = mock('app').as_null_object
+      @env = {'params' => {}}
+      @rp = Goliath::Rack::Validation::RequiredParam.new(@app,
+          :type => 'Monkey',
+          :key => ['data', 'credentials', 'login'],
+          :message => 'is required'
+        )
+    end
+
+    it "return false if key's missing" do
+      @env['params'] = {'data' => {
+          'credentials' => {
+              'login2' => "user",
+              'pass' => "password"}
+            }
+        }
+      
+      @rp.key_valid?(@env['params']).should be_false
+    end
+    
+    it "return true if key is present" do
+      @env['params'] = {'data' => {
+          'credentials' => {
+              'login' => "user",
+              'pass' => "password"}
+            }
+        }
+      
+      @rp.key_valid?(@env['params']).should be_true
+    end
+  end
+  
+  describe 'Nested keys tests (with string)' do
+    before do
+      @app = mock('app').as_null_object
+      @env = {'params' => {}}
+      @rp = Goliath::Rack::Validation::RequiredParam.new(@app,
+          :type => 'Monkey',
+          :key => 'data.credentials.login',
+          :message => 'is required'
+        )
+    end
+
+    it "return false if key's missing" do
+      @env['params'] = {'data' => {
+          'credentials' => {
+              'login2' => "user",
+              'pass' => "password"}
+            }
+        }
+      
+      @rp.key_valid?(@env['params']).should be_false
+    end
+    
+    it "return true if key is present" do
+      @env['params'] = {'data' => {
+          'credentials' => {
+              'login' => "user",
+              'pass' => "password"}
+            }
+        }
+      
+      @rp.key_valid?(@env['params']).should be_true
     end
   end
+  
+  
 end

data/spec/unit/runner_spec.rb

@@ -10,13 +10,6 @@ describe Goliath::Runner do
     @r.stub!(:setup_logger).and_return(@log_mock)
   end
 
-  after(:each) do
-    # Runner default env is development.
-    # We do need to revert to test
-    Goliath.env = :test
-  end
-
-  
   describe 'server execution' do
     describe 'daemonization' do
       it 'daemonizes if specified' do
@@ -140,3 +133,24 @@ describe Goliath::Runner do
     end
   end
 end
+
+describe Goliath::EnvironmentParser do
+  before(:each) do
+    ENV['RACK_ENV'] = nil
+  end
+
+  it 'returns the default environment if no other options are set' do
+    Goliath::EnvironmentParser.parse.should == Goliath::DEFAULT_ENV
+  end
+
+  it 'gives precendence to RACK_ENV over the default' do
+    ENV['RACK_ENV'] = 'rack_env'
+    Goliath::EnvironmentParser.parse.should == :rack_env
+  end
+
+  it 'gives precendence to command-line flag over RACK_ENV' do
+    ENV['RACK_ENV'] = 'rack_env'
+    args = %w{ -e flag_env }
+    Goliath::EnvironmentParser.parse(args).should == :flag_env
+  end
+end

data/test/echo_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class Echo < Goliath::API
+  use Goliath::Rack::Params
+
+  def response(env)
+    [200, {}, env.params['echo']]
+  end
+end
+
+class EchoTest < Test::Unit::TestCase
+  include Goliath::TestHelper
+
+  def setup
+    @err = Proc.new { assert false, "API request failed" }
+  end
+
+  def test_query_is_echoed_back
+    with_api(Echo) do
+      get_request({:query => {:echo => 'test'}}, @err) do |c|
+        assert_equal 'test', c.response
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+
+require 'test/unit'
+require 'goliath/test_helper'
+
+Goliath.env = :test