goliath 1.0.5 → 1.0.6

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

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('NumericRange key required')
+    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('NumericRange requires :min or :max')
+    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

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

@@ -8,39 +8,39 @@ describe Goliath::Rack::Validation::Param do
   end
 
   it "should not allow invalid options" do
-    lambda {
+    expect {
       Goliath::Rack::Validation::Param.new(@app, {:key => 'user', :as => Class.new})
-    }.should raise_error(Exception)
+    }.to raise_error(Exception)
   end
 
   it "raises if key is not supplied" do
-    lambda {
+    expect {
       Goliath::Rack::Validation::Param.new(@app)
-    }.should raise_error(Exception)
+    }.to 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
+    expect(cv.optional).to be false
   end
 
   it "should have default and message be optional" do
     cv = nil
-    lambda {
+    expect {
       cv = Goliath::Rack::Validation::Param.new(@app, {:key => 'flag',
           :as => Goliath::Rack::Types::Boolean})
-    }.should_not raise_error
+    }.not_to raise_error
 
-    cv.default.should be_nil
-    cv.message.should_not be_nil
+    expect(cv.default).to be_nil
+    expect(cv.message).not_to be_nil
   end
 
   it "should fail if given an invalid option" do
     cv = nil
-    lambda {
+    expect {
       cv = Goliath::Rack::Validation::Param.new(@app, {:key => 'flag',
           :as => Goliath::Rack::Types::Boolean, :animal => :monkey})
-    }.should raise_error('Unknown options: {:animal=>:monkey}')
+    }.to raise_error('Unknown options: {:animal=>:monkey}')
   end
 
   context "fetch_key" do
@@ -57,7 +57,7 @@ describe Goliath::Rack::Validation::Param do
           }
         }
       }
-      @cv.fetch_key(params).should == "mike"
+      expect(@cv.fetch_key(params)).to eq("mike")
     end
 
     it "should return nil given an incorrect params" do
@@ -68,7 +68,7 @@ describe Goliath::Rack::Validation::Param do
           }
         }
       }
-      @cv.fetch_key(params).should be_nil
+      expect(@cv.fetch_key(params)).to be_nil
     end
 
     it "should set value if given" do
@@ -79,8 +79,8 @@ describe Goliath::Rack::Validation::Param do
           }
         }
       }
-      @cv.fetch_key(params, "tim").should == "tim"
-      params['data']['credentials']['login'].should == "tim"
+      expect(@cv.fetch_key(params, "tim")).to eq("tim")
+      expect(params['data']['credentials']['login']).to eq("tim")
     end
   end
 
@@ -88,9 +88,9 @@ describe Goliath::Rack::Validation::Param 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'
+      expect(@rp.type).not_to be_nil
+      expect(@rp.type).not_to match(/^\s*$/)
+      expect(@rp.message).to eq('identifier missing')
     end
 
 
@@ -103,76 +103,76 @@ describe Goliath::Rack::Validation::Param do
       end
 
       it 'stores type and key options' do
-        @rp.type.should == 'Monkey'
-        @rp.key.should == 'mk'
+        expect(@rp.type).to eq('Monkey')
+        expect(@rp.key).to eq('mk')
       end
 
       it 'calls validation_error with a custom message' do
-        @rp.should_receive(:validation_error).with(anything, 'Monkey is required')
+        expect(@rp).to 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])
+        expect(@app).to 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
+        expect(status).to eq(201)
+        expect(headers).to eq(app_headers)
+        expect(body).to eq(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
+          expect(@rp.key_valid?(@env['params'])).to be false
         end
 
         it 'raises exception if the key is blank' do
           @env['params']['mk'] = ''
-          @rp.key_valid?(@env['params']).should be false
+          expect(@rp.key_valid?(@env['params'])).to be false
         end
 
         it 'raises exception if the key is nil' do
           @env['params']['mk'] = nil
-          @rp.key_valid?(@env['params']).should be false
+          expect(@rp.key_valid?(@env['params'])).to be false
         end
 
         it 'handles an empty array' do
           @env['params']['mk'] = []
-          @rp.key_valid?(@env['params']).should be false
+          expect(@rp.key_valid?(@env['params'])).to be false
         end
 
         it 'handles an array of nils' do
           @env['params']['mk'] = [nil, nil, nil]
-          @rp.key_valid?(@env['params']).should be false
+          expect(@rp.key_valid?(@env['params'])).to be false
         end
 
         it 'handles an array of blanks' do
           @env['params']['mk'] = ['', '', '']
-          @rp.key_valid?(@env['params']).should be false
+          expect(@rp.key_valid?(@env['params'])).to 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
+          expect(@rp.key_valid?(@env['params'])).to 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
+          expect(@rp.key_valid?(@env['params'])).to 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
+          expect(@rp.key_valid?(@env['params'])).to 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
+          expect(@rp.key_valid?(@env['params'])).to be true
         end
       end
     end
@@ -194,7 +194,7 @@ describe Goliath::Rack::Validation::Param do
         }
         }
 
-        @rp.key_valid?(@env['params']).should be false
+        expect(@rp.key_valid?(@env['params'])).to be false
       end
 
       it "return true if key is present" do
@@ -205,7 +205,7 @@ describe Goliath::Rack::Validation::Param do
         }
         }
 
-        @rp.key_valid?(@env['params']).should be true
+        expect(@rp.key_valid?(@env['params'])).to be true
       end
     end
 
@@ -225,7 +225,7 @@ describe Goliath::Rack::Validation::Param do
         }
         }
 
-        @rp.key_valid?(@env['params']).should be false
+        expect(@rp.key_valid?(@env['params'])).to be false
       end
 
       it "return true if key is present" do
@@ -236,7 +236,7 @@ describe Goliath::Rack::Validation::Param do
         }
         }
 
-        @rp.key_valid?(@env['params']).should be true
+        expect(@rp.key_valid?(@env['params'])).to be true
       end
     end
 
@@ -245,9 +245,9 @@ describe Goliath::Rack::Validation::Param do
   context "Coerce" do
 
     it "should only accept a class in the :as" do
-      lambda {
+      expect {
         Goliath::Rack::Validation::Param.new(@app, {:key => 'user', :as => "not a class"})
-      }.should raise_error('Params as must be a class')
+      }.to raise_error('Params as must be a class')
     end
 
     context 'with middleware' do
@@ -266,7 +266,7 @@ describe Goliath::Rack::Validation::Param 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]
+            expect(@env['params']['user']).to eq(value[1])
           end
         end
       end
@@ -282,9 +282,9 @@ describe Goliath::Rack::Validation::Param 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)
+            expect(result).to be_an_instance_of(Array)
+            expect(result.first).to eq(400)
+            expect(result.last).to have_key(:error)
           end
         end
       end
@@ -292,10 +292,10 @@ describe Goliath::Rack::Validation::Param do
       it "should not fail with a invalid input, given a default value" do
         cv = nil
         @env['params']['user'] = "boo"
-        lambda {
+        expect {
           cv = Goliath::Rack::Validation::Param.new(@app, {:key => 'user',
               :as => Goliath::Rack::Types::Boolean , :default => 'default'})
-        }.should_not raise_error
+        }.not_to raise_error
           @env['params']['user'] = 'default'
       end
 
@@ -305,10 +305,10 @@ describe Goliath::Rack::Validation::Param do
             :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"
+        expect(result).to be_an_instance_of(Array)
+        expect(result.first).to eq(400)
+        expect(result.last).to have_key(:error)
+        expect(result.last[:error]).to eq("custom message")
       end
     end
 
@@ -320,15 +320,15 @@ describe Goliath::Rack::Validation::Param do
           :as => Goliath::Rack::Types::Integer
       @env['params']['login'] = "3"
       cv.call(@env)
-      @env['params']['login'].should == 3
+      expect(@env['params']['login']).to eq(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)
+      expect(result).to be_an_instance_of(Array)
+      expect(result.first).to eq(400)
+      expect(result.last).to have_key(:error)
     end
 
     it "should do required param + coerce (nested)" do
@@ -337,30 +337,30 @@ describe Goliath::Rack::Validation::Param do
       @env['params']['login'] = {}
       @env['params']['login']['other'] = "3"
       cv.call(@env)
-      @env['params']['login']['other'].should == 3
+      expect(@env['params']['login']['other']).to eq(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)
+      expect(result).to be_an_instance_of(Array)
+      expect(result.first).to eq(400)
+      expect(result.last).to 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"
+      expect(@env['params']['login']).to eq("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)
+      expect(result).to be_an_instance_of(Array)
+      expect(result.first).to eq(400)
+      expect(result.last).to have_key(:error)
     end
 
     it "should do required param + not coerce (nested)" do
@@ -368,15 +368,15 @@ describe Goliath::Rack::Validation::Param do
       @env['params']['login'] = {}
       @env['params']['login']['other'] = "3"
       cv.call(@env)
-      @env['params']['login']['other'].should == "3"
+      expect(@env['params']['login']['other']).to eq("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)
+      expect(result).to be_an_instance_of(Array)
+      expect(result.first).to eq(400)
+      expect(result.last).to have_key(:error)
     end
 
     it "should do optional param + coerce (not nested)" do
@@ -384,13 +384,13 @@ describe Goliath::Rack::Validation::Param do
           :as => Goliath::Rack::Types::Integer, :optional => true
       @env['params']['login'] = "3"
       cv.call(@env)
-      @env['params']['login'].should == 3
+      expect(@env['params']['login']).to eq(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
+      expect(result).not_to be_an_instance_of(Array) #implying its OK
     end
 
     it "should do optional param + coerce (nested)" do
@@ -399,14 +399,14 @@ describe Goliath::Rack::Validation::Param do
       @env['params']['login'] = {}
       @env['params']['login']['other'] = "3"
       cv.call(@env)
-      @env['params']['login']['other'].should == 3
+      expect(@env['params']['login']['other']).to eq(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
+      expect(result).not_to be_an_instance_of(Array) #implying its OK
     end
 
     it "should do optional param and not coerce (not nested)" do
@@ -414,13 +414,13 @@ describe Goliath::Rack::Validation::Param do
           :optional => true
       @env['params']['login'] = "3"
       cv.call(@env)
-      @env['params']['login'].should == "3"
+      expect(@env['params']['login']).to eq("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
+      expect(result).not_to be_an_instance_of(Array) #implying its OK
     end
 
     it "should do optional param and not coerce (nested)" do
@@ -429,14 +429,14 @@ describe Goliath::Rack::Validation::Param do
       @env['params']['login'] = {}
       @env['params']['login']['other'] = "3"
       cv.call(@env)
-      @env['params']['login']['other'].should == "3"
+      expect(@env['params']['login']['other']).to eq("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
+      expect(result).not_to be_an_instance_of(Array) #implying its OK
     end
   end
 end