goliath 1.0.5 → 1.0.7

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

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('Must provide defaults to DefaultParams')
+    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('must provide key to DefaultParams')
+    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