goliath 1.0.5 → 1.0.6

data/spec/unit/headers_spec.rb

@@ -8,46 +8,46 @@ describe Goliath::Headers do
 
   it 'outputs in the correct format' do
     @h['my_header'] = 'my_value'
-    @h.to_s.should == "my_header: my_value\r\n"
+    expect(@h.to_s).to eq("my_header: my_value\r\n")
   end
 
   it 'suppresses duplicate keys' do
     @h['my_header'] = 'my_value1'
     @h['my_header'] = 'my_value2'
-    @h.to_s.should == "my_header: my_value1\r\n"
+    expect(@h.to_s).to eq("my_header: my_value1\r\n")
   end
 
   it 'returns true if a key has been set' do
     @h['my_header'] = 'my_value'
-    @h.has_key?('my_header').should be true
+    expect(@h.has_key?('my_header')).to be true
   end
 
   it 'returns false if the key has not been set' do
-    @h.has_key?('my_header').should be false
+    expect(@h.has_key?('my_header')).to be false
   end
 
   it 'ignores nil values' do
     @h['my_header'] = nil
-    @h.to_s.should == ''
+    expect(@h.to_s).to eq('')
   end
 
   it 'allows a value after setting nil' do
     @h['my_header'] = nil
     @h['my_header'] = 'my_value'
-    @h.to_s.should == "my_header: my_value\r\n"
+    expect(@h.to_s).to eq("my_header: my_value\r\n")
   end
 
   it 'formats time as an http time' do
     time = Time.now
     @h['my_time'] = time
-    @h.to_s.should == "my_time: #{time.httpdate}\r\n"
+    expect(@h.to_s).to eq("my_time: #{time.httpdate}\r\n")
   end
 
   %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate).each do |key|
     it "allows #{key} as to be duplicate" do
       @h[key] = 'value1'
       @h[key] = 'value2'
-      @h.to_s.should == "#{key}: value1\r\n#{key}: value2\r\n"
+      expect(@h.to_s).to eq("#{key}: value1\r\n#{key}: value2\r\n")
     end
   end
 end

data/spec/unit/rack/default_mime_type_spec.rb

@@ -14,21 +14,21 @@ describe Goliath::Rack::DefaultMimeType do
   context 'accept header cleanup' do
     it 'handles a nil header' do
       env['HTTP_ACCEPT'] = nil
-      lambda { dmt.call(env) }.should_not raise_error
+      expect { dmt.call(env) }.not_to 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'
+        expect(env['HTTP_ACCEPT']).to eq('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 == '*/*'
+      expect(env['HTTP_ACCEPT']).to eq('*/*')
     end
   end
 end

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

@@ -3,7 +3,7 @@ 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
+    expect { Goliath::Rack::Formatters::JSON.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -13,41 +13,63 @@ describe Goliath::Rack::Formatters::JSON do
     end
 
     it 'checks content type for application/json' do
-      @js.json_response?({'Content-Type' => 'application/json'}).should be_truthy
+      expect(@js.json_response?({'Content-Type' => 'application/json'})).to be_truthy
+    end
+
+    it 'checks content type for application/vnd.api+json' do
+      expect(@js.json_response?({'Content-Type' => 'application/vnd.api+json'})).to be_truthy
+    end
+
+    it 'checks content type for application/javascript' do
+      expect(@js.json_response?({'Content-Type' => 'application/javascript'})).to be_truthy
     end
 
     it 'returns false for non-applicaton/json types' do
-      @js.json_response?({'Content-Type' => 'application/xml'}).should be_falsey
+      expect(@js.json_response?({'Content-Type' => 'application/xml'})).to be_falsey
     end
 
     it 'calls the app with the provided environment' do
       env_mock = double('env').as_null_object
-      @app.should_receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
+      expect(@app).to 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}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+
+      status, header, body = @js.call({})
+      expect { expect(MultiJson.load(body.first)['a']).to eq(1) }.not_to raise_error
+    end
+
+    it 'formats the body into json if content-type is vnd.api+json' do
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/vnd.api+json'}, {:a => 1, :b => 2}])
+
+      status, header, body = @js.call({})
+      expect { expect(MultiJson.load(body.first)['a']).to eq(1) }.not_to raise_error
+    end
+
+    it 'formats the body into json if content-type is javascript' do
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/javascript'}, {:a => 1, :b => 2}])
 
       status, header, body = @js.call({})
-      lambda { MultiJson.load(body.first)['a'].should == 1 }.should_not raise_error
+      expect { expect(MultiJson.load(body.first)['a']).to eq(1) }.not_to raise_error
     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}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      MultiJson.should_not_receive(:dump)
+      expect(MultiJson).not_to receive(:dump)
       status, header, body = @js.call({})
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      MultiJson.should_not_receive(:dump)
+      expect(MultiJson).not_to receive(:dump)
       status, header, body = @js.call({})
-      status.should == 200
-      header.should == {'Content-Type' => 'application/xml'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/xml'})
     end
   end
 end

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

@@ -17,7 +17,7 @@ describe Goliath::Rack::Formatters::PLIST do
   end
 
   it 'accepts an app' do
-    lambda { Goliath::Rack::Formatters::PLIST.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Formatters::PLIST.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -27,23 +27,23 @@ describe Goliath::Rack::Formatters::PLIST do
     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}])
+      expect(@app).to 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}"]
+      expect(body).to eq(["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}])
+      expect(@app).to 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'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/xml'})
 
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
       status, header, body = @m.call({})
     end

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

@@ -4,7 +4,7 @@ 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
+    expect { Goliath::Rack::Formatters::XML.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -14,52 +14,52 @@ describe Goliath::Rack::Formatters::XML do
     end
 
     it 'checks content type for application/xml' do
-      @xml.xml_response?({'Content-Type' => 'application/xml'}).should be_truthy
+      expect(@xml.xml_response?({'Content-Type' => 'application/xml'})).to be_truthy
     end
 
     it 'returns false for non-applicaton/xml types' do
-      @xml.xml_response?({'Content-Type' => 'application/json'}).should be_falsey
+      expect(@xml.xml_response?({'Content-Type' => 'application/json'})).to be_falsey
     end
 
     it 'calls the app with the provided environment' do
       env_mock = double('env').as_null_object
-      @app.should_receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
+      expect(@app).to 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}])
+      expect(@app).to 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
+      expect { expect(Nokogiri.parse(body.first).search('a').inner_text).to eq('1') }.not_to raise_error
     end
 
     it 'generates arrays correctly' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, [1, 2]])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, [1, 2]])
 
       status, header, body = @xml.call({})
-      lambda {
+      expect {
         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
+        expect(doc.search('item').first.inner_text).to eq('1')
+        expect(doc.search('item').last.inner_text).to eq('2')
+      }.not_to raise_error
     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}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
 
-      @xml.should_not_receive(:to_xml)
+      expect(@xml).not_to receive(:to_xml)
       status, header, body = @xml.call({})
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
 
-      @xml.should_not_receive(:to_xml)
+      expect(@xml).not_to receive(:to_xml)
       status, header, body = @xml.call({})
-      status.should == 200
-      header.should == {'Content-Type' => 'application/json'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/json'})
     end
   end
 end

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

@@ -3,7 +3,7 @@ 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
+    expect { Goliath::Rack::Formatters::YAML.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -13,41 +13,41 @@ describe Goliath::Rack::Formatters::YAML do
     end
 
     it 'checks content type for text/yaml' do
-      @ym.yaml_response?({'Content-Type' => 'text/yaml'}).should be_truthy
+      expect(@ym.yaml_response?({'Content-Type' => 'text/yaml'})).to be_truthy
     end
 
     it 'returns false for non-applicaton/yaml types' do
-      @ym.yaml_response?({'Content-Type' => 'application/xml'}).should be_falsey
+      expect(@ym.yaml_response?({'Content-Type' => 'application/xml'})).to be_falsey
     end
 
     it 'calls the app with the provided environment' do
       env_mock = double('env').as_null_object
-      @app.should_receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
+      expect(@app).to 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}])
+      expect(@app).to 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
+      expect { expect(YAML.load(body.first)[:a]).to eq(1) }.not_to 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}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      YAML.should_not_receive(:encode)
+      expect(YAML).not_to receive(:encode)
       status, header, body = @ym.call({})
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      YAML.should_not_receive(:encode)
+      expect(YAML).not_to receive(:encode)
       status, header, body = @ym.call({})
-      status.should == 200
-      header.should == {'Content-Type' => 'application/xml'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/xml'})
     end
   end
 end

data/spec/unit/rack/heartbeat_spec.rb

@@ -4,7 +4,7 @@ require 'goliath/env'
 
 describe Goliath::Rack::Heartbeat do
   it 'accepts an app' do
-    lambda { Goliath::Rack::Heartbeat.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Heartbeat.new('my app') }.not_to raise_error
   end
 
   describe 'with the middleware' do
@@ -16,54 +16,54 @@ describe Goliath::Rack::Heartbeat do
     end
 
     it 'allows /status as a path prefix' do
-      @app.should_receive(:call)
+      expect(@app).to 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)
+      expect(@app).not_to 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'}])
+      expect(@app).to 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'}
+      expect(status).to eq(200)
+      expect(headers).to eq({'a' => 'b'})
+      expect(body).to eq({'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'
+      expect(status).to eq(200)
+      expect(headers).to eq({})
+      expect(body).to eq('OK')
     end
 
     it 'allows path and response to be set using options' do
       @hb = Goliath::Rack::Heartbeat.new(@app, :path => '/isup', :response => [204, {}, nil])
       @env['PATH_INFO'] = '/isup'
       status, headers, body = @hb.call(@env)
-      status.should == 204
-      headers.should == {}
-      body.should == nil
+      expect(status).to eq(204)
+      expect(headers).to eq({})
+      expect(body).to eq(nil)
     end
 
     it 'does not log the request by default' do
       @env['PATH_INFO'] = '/status'
       @hb.call(@env)
-      @env[Goliath::Constants::RACK_LOGGER].should == Log4r::Logger.root
+      expect(@env[Goliath::Constants::RACK_LOGGER]).to eq(Log4r::Logger.root)
     end
 
     it 'logs the request only if asked' do
       @env['PATH_INFO'] = '/status'
       @hb = Goliath::Rack::Heartbeat.new(@app, :log => true)
       @hb.call(@env)
-      @env[Goliath::Constants::RACK_LOGGER].should_not == Log4r::Logger.root
+      expect(@env[Goliath::Constants::RACK_LOGGER]).not_to eq(Log4r::Logger.root)
     end
   end
 end

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
@@ -32,15 +32,15 @@ describe Goliath::Rack::Params 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
@@ -49,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
@@ -80,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
@@ -92,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
@@ -110,12 +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(hash_including("params"=>{"a"=>"b"}))
+      expect(@app).to receive(:call).with(hash_including("params"=>{"a"=>"b"}))
 
       @env['QUERY_STRING'] = "a=b"
       @params.call(@env)
@@ -124,12 +124,12 @@ 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
 
     it 'returns a validation error if one is raised while parsing' do
@@ -171,44 +171,46 @@ Berry\r
         @env['rack.input'].rewind
 
         ret = @params.retrieve_params(@env)
-        ret['foos'].should == 'bonkey'
+        expect(ret['foos']).to eq('bonkey')
       end
 
-      it "parses json" do
-        @env['CONTENT_TYPE'] = 'application/json'
-        @env['rack.input'] = StringIO.new
-        @env['rack.input'] << %|{"foo":"bar"}|
-        @env['rack.input'].rewind
-
-        ret = @params.retrieve_params(@env)
-        ret['foo'].should == 'bar'
-      end
-
-      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
-
-        ret = @params.retrieve_params(@env)
-        ret['_json'].should == ['foo', '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)
+      ['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
@@ -218,7 +220,7 @@ Berry\r
         @env['rack.input'].rewind
 
         ret = @params.retrieve_params(@env)
-        ret.should == {}
+        expect(ret).to eq({})
       end
     end
   end