goliath 1.0.4 → 1.0.6

data/spec/unit/rack/params_spec.rb

@@ -3,7 +3,7 @@ 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
+    expect { Goliath::Rack::Params.new('my app') }.not_to raise_error
   end
 
   describe 'with middleware' do
@@ -21,19 +21,26 @@ describe Goliath::Rack::Params do
       }.to raise_error(Goliath::Validation::BadRequestError)
     end
 
+    it 'handles ambiguous query strings' do
+      @env['QUERY_STRING'] = 'ambiguous[]=&ambiguous[4]='
+      expect {
+        @params.retrieve_params(@env)
+      }.to raise_error(Goliath::Validation::Error)
+    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'
+      expect(ret['foo']).to eq('bar')
+      expect(ret['baz']).to eq('bonkey')
     end
 
     it 'parses the nested query string' do
       @env['QUERY_STRING'] = 'foo[bar]=baz'
 
       ret = @params.retrieve_params(@env)
-      ret['foo'].should == {'bar' => 'baz'}
+      expect(ret['foo']).to eq({'bar' => 'baz'})
     end
 
     it 'parses the post body' do
@@ -42,18 +49,18 @@ describe Goliath::Rack::Params do
       @env['rack.input'].rewind
 
       ret = @params.retrieve_params(@env)
-      ret['foo'].should == 'bar'
-      ret['baz'].should == 'bonkey'
-      ret['zonk'].should == {'donk' => 'monk'}
+      expect(ret['foo']).to eq('bar')
+      expect(ret['baz']).to eq('bonkey')
+      expect(ret['zonk']).to eq({'donk' => 'monk'})
     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)
+      expect(ret['foo'].is_a?(Array)).to be true
+      expect(ret['foo'].length).to eq(3)
+      expect(ret['foo']).to eq(%w(bar baz foos))
     end
 
     it 'parses multipart data' do
@@ -73,8 +80,8 @@ Berry\r
       @env[Goliath::Constants::CONTENT_LENGTH] = @env['rack.input'].length
 
       ret = @params.retrieve_params(@env)
-      ret['submit-name'].should == 'Larry'
-      ret['submit-name-with-content'].should == 'Berry'
+      expect(ret['submit-name']).to eq('Larry')
+      expect(ret['submit-name-with-content']).to eq('Berry')
     end
 
     it 'combines query string and post body params' do
@@ -85,14 +92,14 @@ Berry\r
       @env['rack.input'].rewind
 
       ret = @params.retrieve_params(@env)
-      ret['baz'].should == 'bar'
-      ret['foos'].should == 'bonkey'
+      expect(ret['baz']).to eq('bar')
+      expect(ret['foos']).to eq('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
+      expect(ret.is_a?(Hash)).to be true
+      expect(ret).to be_empty
     end
 
     it 'prefers post body over query string' do
@@ -103,15 +110,12 @@ Berry\r
       @env['rack.input'].rewind
 
       ret = @params.retrieve_params(@env)
-      ret['foo'].should == 'bar2'
-      ret['baz'].should == 'bonkey'
+      expect(ret['foo']).to eq('bar2')
+      expect(ret['baz']).to eq('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
+      expect(@app).to receive(:call).with(hash_including("params"=>{"a"=>"b"}))
 
       @env['QUERY_STRING'] = "a=b"
       @params.call(@env)
@@ -120,60 +124,93 @@ Berry\r
     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])
+      expect(@app).to 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
+      expect(status).to eq(200)
+      expect(headers).to eq(app_headers)
+      expect(body).to eq(app_body)
     end
 
-    context 'content type' do
-      it "parses application/x-www-form-urlencoded" do
-        @env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded; charset=utf-8'
-        @env['rack.input'] = StringIO.new
-        @env['rack.input'] << "foos=bonkey"
-        @env['rack.input'].rewind
+    it 'returns a validation error if one is raised while parsing' do
+      expect(@app).to_not receive(:call)
+      params_exception = Goliath::Validation::Error.new(423, 'invalid')
+      expect(@params).to receive(:retrieve_params).and_raise(params_exception)
+      status, headers, body = @params.call(@env)
+      expect(status).to eq 423
+      expect(headers).to eq({})
+      expect(body).to eq(error: 'invalid')
+    end
 
-        ret = @params.retrieve_params(@env)
-        ret['foos'].should == 'bonkey'
-      end
+    it 'returns a 500 error if an unexpected error is raised while parsing' do
+      expect(@app).to_not receive(:call)
 
-      it "parses json" do
-        @env['CONTENT_TYPE'] = 'application/json'
-        @env['rack.input'] = StringIO.new
-        @env['rack.input'] << %|{"foo":"bar"}|
-        @env['rack.input'].rewind
+      params_exception = Exception.new('uh oh')
+      expect(@params).to receive(:retrieve_params).and_raise(params_exception)
 
-        ret = @params.retrieve_params(@env)
-        ret['foo'].should == 'bar'
-      end
+      logger = double('logger').as_null_object
+      expect(@env).to receive(:logger).twice.and_return(logger)
 
-      it "parses json that does not evaluate to a hash" do
-        @env['CONTENT_TYPE'] = 'application/json'
-        @env['rack.input'] = StringIO.new
-        @env['rack.input'] << %|["foo","bar"]|
-        @env['rack.input'].rewind
+      status, headers, body = @params.call(@env)
+      expect(status).to eq 500
+      expect(headers).to eq({})
+      expect(body).to eq(error: 'uh oh')
+    end
 
-        ret = @params.retrieve_params(@env)
-        ret['_json'].should == ['foo', 'bar']
-      end
+    it 'does not swallow exceptions from the app' do
+      app_exception = Class.new(Exception)
+      expect(@app).to receive(:call).and_raise(app_exception)
+      expect { @params.call(@env) }.to raise_error(app_exception)
+    end
 
-      it "handles empty input gracefully on JSON" do
-        @env['CONTENT_TYPE'] = 'application/json'
+    context 'content type' do
+      it "parses application/x-www-form-urlencoded" do
+        @env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded; charset=utf-8'
         @env['rack.input'] = StringIO.new
+        @env['rack.input'] << "foos=bonkey"
+        @env['rack.input'].rewind
 
         ret = @params.retrieve_params(@env)
-        ret.should be_empty
+        expect(ret['foos']).to eq('bonkey')
       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)
+      ['application/json', 'application/vnd.api+json', 'application/javascript'].each do |content_type|
+        it "parses #{content_type}" do
+          @env['CONTENT_TYPE'] = content_type
+          @env['rack.input'] = StringIO.new
+          @env['rack.input'] << %|{"foo":"bar"}|
+          @env['rack.input'].rewind
+
+          ret = @params.retrieve_params(@env)
+          expect(ret['foo']).to eq('bar')
+        end
+
+        it "parses #{content_type} that does not evaluate to a hash" do
+          @env['CONTENT_TYPE'] = content_type
+          @env['rack.input'] = StringIO.new
+          @env['rack.input'] << %|["foo","bar"]|
+          @env['rack.input'].rewind
+
+          ret = @params.retrieve_params(@env)
+          expect(ret['_json']).to eq(['foo', 'bar'])
+        end
+
+        it "handles empty input gracefully on #{content_type} JSON" do
+          @env['CONTENT_TYPE'] = content_type
+          @env['rack.input'] = StringIO.new
+
+          ret = @params.retrieve_params(@env)
+          expect(ret).to be_empty
+        end
+
+        it "raises a BadRequestError on invalid #{content_type} JSON" do
+          @env['CONTENT_TYPE'] = content_type
+          @env['rack.input'] = StringIO.new
+          @env['rack.input'] << %|{"foo":"bar" BORKEN}|
+          @env['rack.input'].rewind
+
+          expect{ @params.retrieve_params(@env) }.to raise_error(Goliath::Validation::BadRequestError)
+        end
       end
 
       it "doesn't parse unknown content types" do
@@ -183,7 +220,7 @@ Berry\r
         @env['rack.input'].rewind
 
         ret = @params.retrieve_params(@env)
-        ret.should == {}
+        expect(ret).to eq({})
       end
     end
   end

data/spec/unit/rack/render_spec.rb

@@ -13,31 +13,31 @@ describe Goliath::Rack::Render do
   let(:render) { Goliath::Rack::Render.new(app) }
 
   it 'accepts an app' do
-    lambda { Goliath::Rack::Render.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Render.new('my app') }.not_to raise_error
   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])
+    expect(app).to 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
+    expect(status).to eq(200)
+    expect(headers['a']).to eq('b')
+    expect(body).to eq(app_body)
   end
 
   describe 'Vary' do
     it 'adds Accept to provided Vary header' do
-      app.should_receive(:call).and_return([200, {'Vary' => 'Cookie'}, {}])
+      expect(app).to receive(:call).and_return([200, {'Vary' => 'Cookie'}, {}])
       status, headers, body = render.call(env)
-      headers['Vary'].should == 'Cookie,Accept'
+      expect(headers['Vary']).to eq('Cookie,Accept')
     end
 
     it 'sets Accept if there is no Vary header' do
-      app.should_receive(:call).and_return([200, {}, {}])
+      expect(app).to receive(:call).and_return([200, {}, {}])
       status, headers, body = render.call(env)
-      headers['Vary'].should == 'Accept'
+      expect(headers['Vary']).to eq('Accept')
     end
   end
 
@@ -51,7 +51,7 @@ describe Goliath::Rack::Render do
 
   describe 'Content-Type' do
     before(:each) do
-      app.should_receive(:call).and_return([200, {}, {}])
+      expect(app).to receive(:call).and_return([200, {}, {}])
     end
 
     describe 'from header' do
@@ -59,7 +59,7 @@ describe Goliath::Rack::Render do
         it "handles content type for #{type}" do
           env['HTTP_ACCEPT'] = type
           status, headers, body = render.call(env)
-          headers['Content-Type'].should =~ /^#{Regexp.escape(type)}/
+          expect(headers['Content-Type']).to match(/^#{Regexp.escape(type)}/)
         end
       end
     end
@@ -69,7 +69,7 @@ describe Goliath::Rack::Render do
         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)}/
+          expect(headers['Content-Type']).to match(/^#{Regexp.escape(content_type)}/)
         end
       end
     end
@@ -78,14 +78,14 @@ describe Goliath::Rack::Render do
       env['HTTP_ACCEPT'] = 'application/xml'
       env['params']['format'] = 'json'
       status, headers, body = render.call(env)
-      headers['Content-Type'].should =~ %r{^application/json}
+      expect(headers['Content-Type']).to match(%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$/
+        expect(headers['Content-Type']).to match(/; charset=utf-8$/)
       end
     end
   end

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

@@ -14,32 +14,32 @@ describe Goliath::Rack::Validation::BooleanValue do
 
     it 'uses the default if the key is not present' do
       @bv.call(@env)
-      @env['params']['id'].should == true
+      expect(@env['params']['id']).to eq(true)
     end
 
     it 'uses the default if the key is nil' do
       @env['params']['id'] = nil
       @bv.call(@env)
-      @env['params']['id'].should == true
+      expect(@env['params']['id']).to eq(true)
     end
 
     it 'uses the default if the key is blank' do
       @env['params']['id'] = ""
       @bv.call(@env)
-      @env['params']['id'].should == true
+      expect(@env['params']['id']).to eq(true)
     end
 
     it 'a random value is false' do
       @env['params']['id'] = 'blarg'
       @bv.call(@env)
-      @env['params']['id'].should == false
+      expect(@env['params']['id']).to eq(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
+        expect(@env['params']['id']).to eq(true)
       end
     end
 
@@ -47,7 +47,7 @@ describe Goliath::Rack::Validation::BooleanValue do
       it "considers #{type} false" do
         @env['params']['id'] = type
         @bv.call(@env)
-        @env['params']['id'].should == false
+        expect(@env['params']['id']).to eq(false)
       end
     end
   end

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

@@ -4,15 +4,15 @@ 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
+    expect { Goliath::Rack::Validation::DefaultParams.new('my app', opts) }.not_to raise_error
   end
 
   it 'requires defaults to be set' do
-    lambda { Goliath::Rack::Validation::DefaultParams.new('my app', {:key => 'test'}) }.should raise_error
+    expect { Goliath::Rack::Validation::DefaultParams.new('my app', {:key => 'test'}) }.to raise_error('Must provide defaults to DefaultParams')
   end
 
   it 'requires key to be set' do
-    lambda { Goliath::Rack::Validation::DefaultParams.new('my app', {:defaults => 'test'}) }.should raise_error
+    expect { Goliath::Rack::Validation::DefaultParams.new('my app', {:defaults => 'test'}) }.to raise_error('must provide key to DefaultParams')
   end
 
   describe 'with middleware' do
@@ -25,47 +25,47 @@ describe Goliath::Rack::Validation::DefaultParams do
     it 'passes through provided key if set' do
       @env['params']['fl'] = ['pubdate', 'content']
       @rf.call(@env)
-      @env['params']['fl'].should == ['pubdate', 'content']
+      expect(@env['params']['fl']).to eq(['pubdate', 'content'])
     end
 
     it 'sets defaults if no key set' do
       @rf.call(@env)
-      @env['params']['fl'].should == ['title', 'link']
+      expect(@env['params']['fl']).to eq(['title', 'link'])
     end
 
     it 'sets defaults if no key set' do
       @env['params']['fl'] = nil
       @rf.call(@env)
-      @env['params']['fl'].should == ['title', 'link']
+      expect(@env['params']['fl']).to eq(['title', 'link'])
     end
 
     it 'sets defaults if no key is empty' do
       @env['params']['fl'] = []
       @rf.call(@env)
-      @env['params']['fl'].should == ['title', 'link']
+      expect(@env['params']['fl']).to eq(['title', 'link'])
     end
 
     it 'handles a single item' do
       @env['params']['fl'] = 'title'
       @rf.call(@env)
-      @env['params']['fl'].should == 'title'
+      expect(@env['params']['fl']).to eq('title')
     end
 
     it 'handles a blank string' do
       @env['params']['fl'] = ''
       @rf.call(@env)
-      @env['params']['fl'].should == ['title', 'link']
+      expect(@env['params']['fl']).to eq(['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])
+      expect(@app).to 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
+      expect(status).to eq(200)
+      expect(headers).to eq(app_headers)
+      expect(body).to eq(app_body)
     end
   end
 end

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

@@ -9,7 +9,7 @@ describe Goliath::Rack::Validation::NumericRange do
 
   it 'accepts options on create' do
     opts = { :min => 1, :key => 2 }
-    lambda { Goliath::Rack::Validation::NumericRange.new('my app', opts) }.should_not raise_error
+    expect { Goliath::Rack::Validation::NumericRange.new('my app', opts) }.not_to raise_error
   end
 
   describe 'with middleware' do
@@ -20,41 +20,41 @@ describe Goliath::Rack::Validation::NumericRange do
     it 'uses the default if value is less then min' do
       @env['params']['id'] = -10
       @nr.call(@env)
-      @env['params']['id'].should == 15
+      expect(@env['params']['id']).to eq(15)
     end
 
     it 'uses the default if value is greater then max' do
       @env['params']['id'] = 25
       @nr.call(@env)
-      @env['params']['id'].should == 15
+      expect(@env['params']['id']).to eq(15)
     end
 
     it 'uses the first value, if the value is an array' do
       @env['params']['id'] = [10, 11, 12]
       @nr.call(@env)
-      @env['params']['id'].should == 10
+      expect(@env['params']['id']).to eq(10)
     end
 
     it 'uses the default if value is not present' do
       @nr.call(@env)
-      @env['params']['id'].should == 15
+      expect(@env['params']['id']).to eq(15)
     end
 
     it 'uses the default if value is nil' do
       @env['params']['id'] = nil
       @nr.call(@env)
-      @env['params']['id'].should == 15
+      expect(@env['params']['id']).to eq(15)
     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([200, app_headers, app_body])
+      expect(@app).to receive(:call).and_return([200, app_headers, app_body])
 
       status, headers, body = @nr.call(@env)
-      status.should == 200
-      headers.should == app_headers
-      body.should == app_body
+      expect(status).to eq(200)
+      expect(headers).to eq(app_headers)
+      expect(body).to eq(app_body)
     end
   end
 
@@ -62,42 +62,42 @@ describe Goliath::Rack::Validation::NumericRange 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
+    expect(@env['params']['id']).to eq(1.5)
   end
 
   it 'raises error if key is not set' do
-    lambda { Goliath::Rack::Validation::NumericRange.new('app', {:min => 5}) }.should raise_error
+    expect { Goliath::Rack::Validation::NumericRange.new('app', {:min => 5}) }.to raise_error('NumericRange key required')
   end
 
   it 'raises error if neither min nor max set' do
-    lambda { Goliath::Rack::Validation::NumericRange.new('app', {:key => 5}) }.should raise_error
+    expect { Goliath::Rack::Validation::NumericRange.new('app', {:key => 5}) }.to raise_error('NumericRange requires :min or :max')
   end
 
   it 'uses min if default not set' do
     nr = Goliath::Rack::Validation::NumericRange.new(@app, {:key => 'id', :min => 5, :max => 10})
     @env['params']['id'] = 15
     nr.call(@env)
-    @env['params']['id'].should == 5
+    expect(@env['params']['id']).to eq(5)
   end
 
   it 'uses max if default and min not set' do
     nr = Goliath::Rack::Validation::NumericRange.new(@app, {:key => 'id', :max => 10})
     @env['params']['id'] = 15
     nr.call(@env)
-    @env['params']['id'].should == 10
+    expect(@env['params']['id']).to eq(10)
   end
 
   it "doesn't require min" do
     nr = Goliath::Rack::Validation::NumericRange.new(@app, {:key => 'id', :max => 10})
     @env['params']['id'] = 8
     nr.call(@env)
-    @env['params']['id'].should == 8
+    expect(@env['params']['id']).to eq(8)
   end
 
   it "doesn't require max" do
     nr = Goliath::Rack::Validation::NumericRange.new(@app, {:key => 'id', :min => 1})
     @env['params']['id'] = 15
     nr.call(@env)
-    @env['params']['id'].should == 15
+    expect(@env['params']['id']).to eq(15)
   end
 end