grape 0.7.0 → 0.8.0

data/spec/grape/middleware/versioner/param_spec.rb

@@ -7,30 +7,30 @@ describe Grape::Middleware::Versioner::Param do
 
   it 'sets the API version based on the default param (apiver)' do
     env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1" })
-    subject.call(env)[1]["api.version"].should == 'v1'
+    expect(subject.call(env)[1]["api.version"]).to eq('v1')
   end
 
-  it 'cuts (only) the version out of the params', focus: true do
+  it 'cuts (only) the version out of the params' do
     env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1", "other_param" => "5" })
     env['rack.request.query_hash'] = Rack::Utils.parse_nested_query(env['QUERY_STRING'])
-    subject.call(env)[1]['rack.request.query_hash']["apiver"].should be_nil
-    subject.call(env)[1]['rack.request.query_hash']["other_param"].should == "5"
+    expect(subject.call(env)[1]['rack.request.query_hash']["apiver"]).to be_nil
+    expect(subject.call(env)[1]['rack.request.query_hash']["other_param"]).to eq("5")
   end
 
   it 'provides a nil version if no version is given' do
     env = Rack::MockRequest.env_for("/")
-    subject.call(env).last.should be_nil
+    expect(subject.call(env).last).to be_nil
   end
 
   context 'with specified parameter name' do
     before { @options = { parameter: 'v' } }
     it 'sets the API version based on the custom parameter name' do
       env = Rack::MockRequest.env_for("/awesome", params: { "v" => "v1" })
-      subject.call(env)[1]["api.version"].should == "v1"
+      expect(subject.call(env)[1]["api.version"]).to eq("v1")
     end
     it 'does not set the API version based on the default param' do
       env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1" })
-      subject.call(env)[1]["api.version"].should be_nil
+      expect(subject.call(env)[1]["api.version"]).to be_nil
     end
   end
 
@@ -38,11 +38,11 @@ describe Grape::Middleware::Versioner::Param do
     before { @options = { versions: ['v1', 'v2'] } }
     it 'throws an error if a non-allowed version is specified' do
       env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v3" })
-      catch(:error) { subject.call(env) }[:status].should == 404
+      expect(catch(:error) { subject.call(env) }[:status]).to eq(404)
     end
     it 'allows versions that have been specified' do
       env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1" })
-      subject.call(env)[1]["api.version"].should == 'v1'
+      expect(subject.call(env)[1]["api.version"]).to eq('v1')
     end
   end
 
@@ -52,7 +52,7 @@ describe Grape::Middleware::Versioner::Param do
       version_options: { using: :header }
     }
     env = Rack::MockRequest.env_for("/awesome", params: {})
-    subject.call(env).first.should == 200
+    expect(subject.call(env).first).to eq(200)
   end
 
 end

data/spec/grape/middleware/versioner/path_spec.rb

@@ -5,25 +5,25 @@ describe Grape::Middleware::Versioner::Path do
   subject { Grape::Middleware::Versioner::Path.new(app, @options || {}) }
 
   it 'sets the API version based on the first path' do
-    subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
+    expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
   end
 
   it 'does not cut the version out of the path' do
-    subject.call('PATH_INFO' => '/v1/awesome')[1]['PATH_INFO'].should == '/v1/awesome'
+    expect(subject.call('PATH_INFO' => '/v1/awesome')[1]['PATH_INFO']).to eq('/v1/awesome')
   end
 
   it 'provides a nil version if no path is given' do
-    subject.call('PATH_INFO' => '/').last.should be_nil
+    expect(subject.call('PATH_INFO' => '/').last).to be_nil
   end
 
   context 'with a pattern' do
     before { @options = { pattern: /v./i } }
     it 'sets the version if it matches' do
-      subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
+      expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
     end
 
     it 'ignores the version if it fails to match' do
-      subject.call('PATH_INFO' => '/awesome/radical').last.should be_nil
+      expect(subject.call('PATH_INFO' => '/awesome/radical').last).to be_nil
     end
   end
 
@@ -32,11 +32,11 @@ describe Grape::Middleware::Versioner::Path do
       before { @options = { versions: versions } }
 
       it 'throws an error if a non-allowed version is specified' do
-        catch(:error) { subject.call('PATH_INFO' => '/v3/awesome') }[:status].should == 404
+        expect(catch(:error) { subject.call('PATH_INFO' => '/v3/awesome') }[:status]).to eq(404)
       end
 
       it 'allows versions that have been specified' do
-        subject.call('PATH_INFO' => '/v1/asoasd').last.should == 'v1'
+        expect(subject.call('PATH_INFO' => '/v1/asoasd').last).to eq('v1')
       end
     end
   end

data/spec/grape/middleware/versioner_spec.rb

@@ -5,18 +5,18 @@ describe Grape::Middleware::Versioner do
   let(:klass) { Grape::Middleware::Versioner }
 
   it 'recognizes :path' do
-    klass.using(:path).should == Grape::Middleware::Versioner::Path
+    expect(klass.using(:path)).to eq(Grape::Middleware::Versioner::Path)
   end
 
   it 'recognizes :header' do
-    klass.using(:header).should == Grape::Middleware::Versioner::Header
+    expect(klass.using(:header)).to eq(Grape::Middleware::Versioner::Header)
   end
 
   it 'recognizes :param' do
-    klass.using(:param).should == Grape::Middleware::Versioner::Param
+    expect(klass.using(:param)).to eq(Grape::Middleware::Versioner::Param)
   end
 
   it 'recognizes :accept_version_header' do
-    klass.using(:accept_version_header).should == Grape::Middleware::Versioner::AcceptVersionHeader
+    expect(klass.using(:accept_version_header)).to eq(Grape::Middleware::Versioner::AcceptVersionHeader)
   end
 end

data/spec/grape/path_spec.rb

@@ -185,7 +185,7 @@ module Grape
       context "when path versioning is used" do
         it "includes a '/'" do
           path = Path.new(nil, nil, {})
-          path.stub(:uses_path_versioning?) { true }
+          allow(path).to receive(:uses_path_versioning?) { true }
 
           expect(path.suffix).to eql('(/.:format)')
         end
@@ -194,21 +194,21 @@ module Grape
       context "when path versioning is not used" do
         it "does not include a '/' when the path has a namespace" do
           path = Path.new(nil, 'namespace', {})
-          path.stub(:uses_path_versioning?) { true }
+          allow(path).to receive(:uses_path_versioning?) { true }
 
           expect(path.suffix).to eql('(.:format)')
         end
 
         it "does not include a '/' when the path has a path" do
           path = Path.new('/path', nil, {})
-          path.stub(:uses_path_versioning?) { true }
+          allow(path).to receive(:uses_path_versioning?) { true }
 
           expect(path.suffix).to eql('(.:format)')
         end
 
         it "includes a '/' otherwise" do
           path = Path.new(nil, nil, {})
-          path.stub(:uses_path_versioning?) { true }
+          allow(path).to receive(:uses_path_versioning?) { true }
 
           expect(path.suffix).to eql('(/.:format)')
         end
@@ -218,8 +218,8 @@ module Grape
     describe "#path_with_suffix" do
       it "combines the path and suffix" do
         path = Path.new(nil, nil, {})
-        path.stub(:path) { '/the/path' }
-        path.stub(:suffix) { 'suffix' }
+        allow(path).to receive(:path) { '/the/path' }
+        allow(path).to receive(:suffix) { 'suffix' }
 
         expect(path.path_with_suffix).to eql('/the/pathsuffix')
       end

data/spec/grape/util/hash_stack_spec.rb

@@ -6,11 +6,11 @@ describe Grape::Util::HashStack do
     it 'finds the first available key' do
       subject[:abc] = 123
       subject.push(abc: 345)
-      subject.get(:abc).should == 345
+      expect(subject.get(:abc)).to eq(345)
     end
 
     it 'is nil if the key has not been set' do
-      subject[:abc].should be_nil
+      expect(subject[:abc]).to be_nil
     end
   end
 
@@ -18,7 +18,7 @@ describe Grape::Util::HashStack do
     it 'sets a value on the highest frame' do
       subject.push
       subject.set(:abc, 123)
-      subject.stack.last[:abc].should == 123
+      expect(subject.stack.last[:abc]).to eq(123)
     end
   end
 
@@ -27,96 +27,96 @@ describe Grape::Util::HashStack do
       subject[:abc] = []
       subject.imbue :abc, [123]
       subject.imbue :abc, [456]
-      subject[:abc].should == [123, 456]
+      expect(subject[:abc]).to eq([123, 456])
     end
 
     it 'merges a hash that is passed' do
       subject[:abc] = { foo: 'bar' }
       subject.imbue :abc, baz: 'wich'
-      subject[:abc].should == { foo: 'bar', baz: 'wich' }
+      expect(subject[:abc]).to eq(foo: 'bar', baz: 'wich')
     end
 
     it 'sets the value if not a hash or array' do
       subject.imbue :abc, 123
-      subject[:abc].should == 123
+      expect(subject[:abc]).to eq(123)
     end
 
     it 'is able to imbue an array without explicit setting' do
       subject.imbue :arr, [1]
       subject.imbue :arr, [2]
-      subject[:arr].should == [1, 2]
+      expect(subject[:arr]).to eq([1, 2])
     end
 
     it 'is able to imbue a hash without explicit setting' do
       subject.imbue :hash, foo: 'bar'
       subject.imbue :hash, baz: 'wich'
-      subject[:hash].should == { foo: 'bar', baz: 'wich' }
+      expect(subject[:hash]).to eq(foo: 'bar', baz: 'wich')
     end
   end
 
   describe '#push' do
     it 'returns a HashStack' do
-      subject.push(Grape::Util::HashStack.new).should be_kind_of(Grape::Util::HashStack)
+      expect(subject.push(Grape::Util::HashStack.new)).to be_kind_of(Grape::Util::HashStack)
     end
 
     it 'places the passed value on the top of the stack' do
       subject.push(abc: 123)
-      subject.stack.should == [{}, { abc: 123 }]
+      expect(subject.stack).to eq([{}, { abc: 123 }])
     end
 
     it 'pushes an empty hash by default' do
       subject[:abc] = 123
       subject.push
-      subject.stack.should == [{ abc: 123 }, {}]
+      expect(subject.stack).to eq([{ abc: 123 }, {}])
     end
   end
 
   describe '#pop' do
     it 'removes and return the top frame' do
       subject.push(abc: 123)
-      subject.pop.should == { abc: 123 }
-      subject.stack.size.should == 1
+      expect(subject.pop).to eq(abc: 123)
+      expect(subject.stack.size).to eq(1)
     end
   end
 
   describe '#peek' do
     it 'returns the top frame without removing it' do
       subject.push(abc: 123)
-      subject.peek.should == { abc: 123 }
-      subject.stack.size.should == 2
+      expect(subject.peek).to eq(abc: 123)
+      expect(subject.stack.size).to eq(2)
     end
   end
 
   describe '#prepend' do
     it 'returns a HashStack' do
-      subject.prepend(Grape::Util::HashStack.new).should be_kind_of(Grape::Util::HashStack)
+      expect(subject.prepend(Grape::Util::HashStack.new)).to be_kind_of(Grape::Util::HashStack)
     end
 
     it "prepends a HashStack's stack onto its own stack" do
       other = Grape::Util::HashStack.new.push(abc: 123)
-      subject.prepend(other).stack.should == [{}, { abc: 123 }, {}]
+      expect(subject.prepend(other).stack).to eq([{}, { abc: 123 }, {}])
     end
   end
 
   describe '#concat' do
     it 'returns a HashStack' do
-      subject.concat(Grape::Util::HashStack.new).should be_kind_of(Grape::Util::HashStack)
+      expect(subject.concat(Grape::Util::HashStack.new)).to be_kind_of(Grape::Util::HashStack)
     end
 
     it "appends a HashStack's stack onto its own stack" do
       other = Grape::Util::HashStack.new.push(abc: 123)
-      subject.concat(other).stack.should == [{}, {}, { abc: 123 }]
+      expect(subject.concat(other).stack).to eq([{}, {}, { abc: 123 }])
     end
   end
 
   describe '#update' do
     it 'merges! into the top frame' do
       subject.update(abc: 123)
-      subject.stack.should == [{ abc: 123 }]
+      expect(subject.stack).to eq([{ abc: 123 }])
     end
 
     it 'returns a HashStack' do
-      subject.update(abc: 123).should be_kind_of(Grape::Util::HashStack)
+      expect(subject.update(abc: 123)).to be_kind_of(Grape::Util::HashStack)
     end
   end
 
@@ -126,7 +126,7 @@ describe Grape::Util::HashStack do
       subject.push def: 234
       clone = subject.clone
       clone[:def] = 345
-      subject[:def].should == 234
+      expect(subject[:def]).to eq(234)
     end
   end
 end

data/spec/grape/validations/coerce_spec.rb

@@ -30,8 +30,8 @@ describe Grape::Validations::CoerceValidator do
         end
 
         get '/single', age: '43a'
-        last_response.status.should == 400
-        last_response.body.should == '年龄格式不正确'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('年龄格式不正确')
       end
 
       it 'gives an english fallback error when default locale message is blank' do
@@ -44,8 +44,8 @@ describe Grape::Validations::CoerceValidator do
         end
 
         get '/single', age: '43a'
-        last_response.status.should == 400
-        last_response.body.should == 'age is invalid'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('age is invalid')
       end
 
     end
@@ -59,12 +59,12 @@ describe Grape::Validations::CoerceValidator do
       end
 
       get '/single', int: '43a'
-      last_response.status.should == 400
-      last_response.body.should == 'int is invalid'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('int is invalid')
 
       get '/single', int: '43'
-      last_response.status.should == 200
-      last_response.body.should == 'int works'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('int works')
     end
 
     it 'error on malformed input (Array)' do
@@ -76,12 +76,12 @@ describe Grape::Validations::CoerceValidator do
       end
 
       get 'array', ids: ['1', '2', 'az']
-      last_response.status.should == 400
-      last_response.body.should == 'ids is invalid'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('ids is invalid')
 
       get 'array', ids: ['1', '2', '890']
-      last_response.status.should == 200
-      last_response.body.should == 'array int works'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('array int works')
     end
 
     context 'complex objects' do
@@ -102,12 +102,12 @@ describe Grape::Validations::CoerceValidator do
         end
 
         get '/user', user: "32"
-        last_response.status.should == 400
-        last_response.body.should == 'user is invalid'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('user is invalid')
 
         get '/user', user: { id: 32, name: 'Bob' }
-        last_response.status.should == 200
-        last_response.body.should == 'complex works'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('complex works')
       end
     end
 
@@ -121,8 +121,8 @@ describe Grape::Validations::CoerceValidator do
         end
 
         get '/int', int: "45"
-        last_response.status.should == 200
-        last_response.body.should == 'Fixnum'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Fixnum')
       end
 
       it 'Array of Integers' do
@@ -134,8 +134,8 @@ describe Grape::Validations::CoerceValidator do
         end
 
         get '/array', arry: ['1', '2', '3']
-        last_response.status.should == 200
-        last_response.body.should == 'Fixnum'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Fixnum')
       end
 
       it 'Array of Bools' do
@@ -147,8 +147,8 @@ describe Grape::Validations::CoerceValidator do
         end
 
         get 'array', arry: [1, 0]
-        last_response.status.should == 200
-        last_response.body.should == 'TrueClass'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('TrueClass')
       end
 
       it 'Bool' do
@@ -160,20 +160,20 @@ describe Grape::Validations::CoerceValidator do
         end
 
         get '/bool', bool: 1
-        last_response.status.should == 200
-        last_response.body.should == 'TrueClass'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('TrueClass')
 
         get '/bool', bool: 0
-        last_response.status.should == 200
-        last_response.body.should == 'FalseClass'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('FalseClass')
 
         get '/bool', bool: 'false'
-        last_response.status.should == 200
-        last_response.body.should == 'FalseClass'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('FalseClass')
 
         get '/bool', bool: 'true'
-        last_response.status.should == 200
-        last_response.body.should == 'TrueClass'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('TrueClass')
       end
 
       it 'file' do
@@ -185,8 +185,8 @@ describe Grape::Validations::CoerceValidator do
         end
 
         post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
-        last_response.status.should == 201
-        last_response.body.should == File.basename(__FILE__).to_s
+        expect(last_response.status).to eq(201)
+        expect(last_response.body).to eq(File.basename(__FILE__).to_s)
       end
 
       it 'Nests integers' do
@@ -200,8 +200,8 @@ describe Grape::Validations::CoerceValidator do
         end
 
         get '/int', integers: { int: "45" }
-        last_response.status.should == 200
-        last_response.body.should == 'Fixnum'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Fixnum')
       end
     end
   end