grape 1.5.2 → 1.7.0

data/spec/grape/middleware/stack_spec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Middleware::Stack do
   module StackSpec
     class FooMiddleware; end
+
     class BarMiddleware; end
+
     class BlockMiddleware
       attr_reader :block
 
@@ -15,10 +15,10 @@ describe Grape::Middleware::Stack do
     end
   end
 
-  let(:proc) { ->() {} }
-  let(:others) { [[:use, StackSpec::BarMiddleware], [:insert_before, StackSpec::BarMiddleware, StackSpec::BlockMiddleware, proc]] }
+  subject { described_class.new }
 
-  subject { Grape::Middleware::Stack.new }
+  let(:proc) { -> {} }
+  let(:others) { [[:use, StackSpec::BarMiddleware], [:insert_before, StackSpec::BarMiddleware, StackSpec::BlockMiddleware, proc]] }
 
   before do
     subject.use StackSpec::FooMiddleware
@@ -27,20 +27,20 @@ describe Grape::Middleware::Stack do
   describe '#use' do
     it 'pushes a middleware class onto the stack' do
       expect { subject.use StackSpec::BarMiddleware }
-        .to change { subject.size }.by(1)
+        .to change(subject, :size).by(1)
       expect(subject.last).to eq(StackSpec::BarMiddleware)
     end
 
     it 'pushes a middleware class with arguments onto the stack' do
       expect { subject.use StackSpec::BarMiddleware, false, my_arg: 42 }
-        .to change { subject.size }.by(1)
+        .to change(subject, :size).by(1)
       expect(subject.last).to eq(StackSpec::BarMiddleware)
       expect(subject.last.args).to eq([false, { my_arg: 42 }])
     end
 
     it 'pushes a middleware class with block arguments onto the stack' do
       expect { subject.use StackSpec::BlockMiddleware, &proc }
-        .to change { subject.size }.by(1)
+        .to change(subject, :size).by(1)
       expect(subject.last).to eq(StackSpec::BlockMiddleware)
       expect(subject.last.args).to eq([])
       expect(subject.last.block).to eq(proc)
@@ -50,7 +50,7 @@ describe Grape::Middleware::Stack do
   describe '#insert' do
     it 'inserts a middleware class at the integer index' do
       expect { subject.insert 0, StackSpec::BarMiddleware }
-        .to change { subject.size }.by(1)
+        .to change(subject, :size).by(1)
       expect(subject[0]).to eq(StackSpec::BarMiddleware)
       expect(subject[1]).to eq(StackSpec::FooMiddleware)
     end
@@ -59,7 +59,7 @@ describe Grape::Middleware::Stack do
   describe '#insert_before' do
     it 'inserts a middleware before another middleware class' do
       expect { subject.insert_before StackSpec::FooMiddleware, StackSpec::BarMiddleware }
-        .to change { subject.size }.by(1)
+        .to change(subject, :size).by(1)
       expect(subject[0]).to eq(StackSpec::BarMiddleware)
       expect(subject[1]).to eq(StackSpec::FooMiddleware)
     end
@@ -68,7 +68,7 @@ describe Grape::Middleware::Stack do
       subject.use Class.new(StackSpec::BlockMiddleware)
 
       expect { subject.insert_before StackSpec::BlockMiddleware, StackSpec::BarMiddleware }
-        .to change { subject.size }.by(1)
+        .to change(subject, :size).by(1)
 
       expect(subject[1]).to eq(StackSpec::BarMiddleware)
       expect(subject[2]).to eq(StackSpec::BlockMiddleware)
@@ -83,7 +83,7 @@ describe Grape::Middleware::Stack do
   describe '#insert_after' do
     it 'inserts a middleware after another middleware class' do
       expect { subject.insert_after StackSpec::FooMiddleware, StackSpec::BarMiddleware }
-        .to change { subject.size }.by(1)
+        .to change(subject, :size).by(1)
       expect(subject[1]).to eq(StackSpec::BarMiddleware)
       expect(subject[0]).to eq(StackSpec::FooMiddleware)
     end
@@ -92,7 +92,7 @@ describe Grape::Middleware::Stack do
       subject.use Class.new(StackSpec::BlockMiddleware)
 
       expect { subject.insert_after StackSpec::BlockMiddleware, StackSpec::BarMiddleware }
-        .to change { subject.size }.by(1)
+        .to change(subject, :size).by(1)
 
       expect(subject[1]).to eq(StackSpec::BlockMiddleware)
       expect(subject[2]).to eq(StackSpec::BarMiddleware)
@@ -107,7 +107,7 @@ describe Grape::Middleware::Stack do
   describe '#merge_with' do
     it 'applies a collection of operations and middlewares' do
       expect { subject.merge_with(others) }
-        .to change { subject.size }.by(2)
+        .to change(subject, :size).by(2)
       expect(subject[0]).to eq(StackSpec::FooMiddleware)
       expect(subject[1]).to eq(StackSpec::BlockMiddleware)
       expect(subject[2]).to eq(StackSpec::BarMiddleware)

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

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Middleware::Versioner::AcceptVersionHeader do
+  subject { described_class.new(app, **(@options || {})) }
+
   let(:app) { ->(env) { [200, env, env] } }
-  subject { Grape::Middleware::Versioner::AcceptVersionHeader.new(app, **(@options || {})) }
 
   before do
     @options = {

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

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Middleware::Versioner::Header do
+  subject { described_class.new(app, **(@options || {})) }
+
   let(:app) { ->(env) { [200, env, env] } }
-  subject { Grape::Middleware::Versioner::Header.new(app, **(@options || {})) }
 
   before do
     @options = {
@@ -47,7 +46,7 @@ describe Grape::Middleware::Versioner::Header do
 
     it 'is nil if not provided' do
       status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor')
-      expect(env['api.format']).to eql nil
+      expect(env['api.format']).to be_nil
       expect(status).to eq(200)
     end
 
@@ -65,7 +64,7 @@ describe Grape::Middleware::Versioner::Header do
 
         it 'is nil if not provided' do
           status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1')
-          expect(env['api.format']).to eql nil
+          expect(env['api.format']).to be_nil
           expect(status).to eq(200)
         end
       end
@@ -90,7 +89,7 @@ describe Grape::Middleware::Versioner::Header do
         .to raise_exception do |exception|
           expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
           expect(exception.headers).to eql('X-Cascade' => 'pass')
-          expect(exception.status).to eql 406
+          expect(exception.status).to be 406
           expect(exception.message).to include 'API vendor not found'
         end
     end
@@ -117,7 +116,7 @@ describe Grape::Middleware::Versioner::Header do
           .to raise_exception do |exception|
             expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
             expect(exception.headers).to eql('X-Cascade' => 'pass')
-            expect(exception.status).to eql 406
+            expect(exception.status).to be 406
             expect(exception.message).to include('API vendor not found')
           end
       end
@@ -145,7 +144,7 @@ describe Grape::Middleware::Versioner::Header do
       expect { subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v2+json').last }.to raise_exception do |exception|
         expect(exception).to be_a(Grape::Exceptions::InvalidVersionHeader)
         expect(exception.headers).to eql('X-Cascade' => 'pass')
-        expect(exception.status).to eql 406
+        expect(exception.status).to be 406
         expect(exception.message).to include('API version not found')
       end
     end
@@ -178,7 +177,7 @@ describe Grape::Middleware::Versioner::Header do
       expect { subject.call({}).last }.to raise_exception do |exception|
         expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
         expect(exception.headers).to eql('X-Cascade' => 'pass')
-        expect(exception.status).to eql 406
+        expect(exception.status).to be 406
         expect(exception.message).to include('Accept header must be set.')
       end
     end
@@ -187,7 +186,7 @@ describe Grape::Middleware::Versioner::Header do
       expect { subject.call('HTTP_ACCEPT' => '').last }.to raise_exception do |exception|
         expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
         expect(exception.headers).to eql('X-Cascade' => 'pass')
-        expect(exception.status).to eql 406
+        expect(exception.status).to be 406
         expect(exception.message).to include('Accept header must be set.')
       end
     end
@@ -208,7 +207,7 @@ describe Grape::Middleware::Versioner::Header do
       expect { subject.call({}).last }.to raise_exception do |exception|
         expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
         expect(exception.headers).to eql({})
-        expect(exception.status).to eql 406
+        expect(exception.status).to be 406
         expect(exception.message).to include('Accept header must be set.')
       end
     end
@@ -218,7 +217,7 @@ describe Grape::Middleware::Versioner::Header do
         .to raise_exception do |exception|
         expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
         expect(exception.headers).to eql({})
-        expect(exception.status).to eql 406
+        expect(exception.status).to be 406
         expect(exception.message).to include('API vendor or version not found.')
       end
     end
@@ -227,7 +226,7 @@ describe Grape::Middleware::Versioner::Header do
       expect { subject.call('HTTP_ACCEPT' => '').last }.to raise_exception do |exception|
         expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
         expect(exception.headers).to eql({})
-        expect(exception.status).to eql 406
+        expect(exception.status).to be 406
         expect(exception.message).to include('Accept header must be set.')
       end
     end
@@ -237,7 +236,7 @@ describe Grape::Middleware::Versioner::Header do
         .to raise_exception do |exception|
         expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
         expect(exception.headers).to eql({})
-        expect(exception.status).to eql 406
+        expect(exception.status).to be 406
         expect(exception.message).to include('API vendor or version not found.')
       end
     end
@@ -264,7 +263,7 @@ describe Grape::Middleware::Versioner::Header do
       expect { subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v3+json') }.to raise_exception do |exception|
         expect(exception).to be_a(Grape::Exceptions::InvalidVersionHeader)
         expect(exception.headers).to eql('X-Cascade' => 'pass')
-        expect(exception.status).to eql 406
+        expect(exception.status).to be 406
         expect(exception.message).to include('API version not found')
       end
     end
@@ -327,4 +326,20 @@ describe Grape::Middleware::Versioner::Header do
       end
     end
   end
+
+  context 'with missing vendor option' do
+    subject do
+      Class.new(Grape::API) do
+        version 'v1', using: :header
+      end
+    end
+
+    def app
+      subject
+    end
+
+    it 'fails' do
+      expect { versioned_get '/', 'v1', using: :header }.to raise_error Grape::Exceptions::MissingVendorOption
+    end
+  end
 end

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

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Middleware::Versioner::Param do
+  subject { described_class.new(app, **options) }
+
   let(:app) { ->(env) { [200, env, env['api.version']] } }
   let(:options) { {} }
-  subject { Grape::Middleware::Versioner::Param.new(app, **options) }
 
   it 'sets the API version based on the default param (apiver)' do
     env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1' })
@@ -26,10 +25,12 @@ describe Grape::Middleware::Versioner::Param do
 
   context 'with specified parameter name' do
     let(:options) { { version_options: { parameter: 'v' } } }
+
     it 'sets the API version based on the custom parameter name' do
       env = Rack::MockRequest.env_for('/awesome', params: { 'v' => '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' })
       expect(subject.call(env)[1]['api.version']).to be_nil
@@ -38,10 +39,12 @@ describe Grape::Middleware::Versioner::Param do
 
   context 'with specified versions' do
     let(:options) { { versions: %w[v1 v2] } }
+
     it 'throws an error if a non-allowed version is specified' do
       env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v3' })
       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' })
       expect(subject.call(env)[1]['api.version']).to eq('v1')
@@ -55,6 +58,7 @@ describe Grape::Middleware::Versioner::Param do
         version_options: { using: :header }
       }
     end
+
     it 'returns a 200 (matches the first version found)' do
       env = Rack::MockRequest.env_for('/awesome', params: {})
       expect(subject.call(env).first).to eq(200)

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

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Middleware::Versioner::Path do
+  subject { described_class.new(app, **options) }
+
   let(:app) { ->(env) { [200, env, env['api.version']] } }
   let(:options) { {} }
-  subject { Grape::Middleware::Versioner::Path.new(app, **options) }
 
   it 'sets the API version based on the first path' do
     expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
@@ -21,6 +20,7 @@ describe Grape::Middleware::Versioner::Path do
 
   context 'with a pattern' do
     let(:options) { { pattern: /v./i } }
+
     it 'sets the version if it matches' do
       expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
     end
@@ -46,6 +46,7 @@ describe Grape::Middleware::Versioner::Path do
 
   context 'with prefix, but requested version is not matched' do
     let(:options) { { prefix: '/v1', pattern: /v./i } }
+
     it 'recognizes potential version' do
       expect(subject.call('PATH_INFO' => '/v3/foo').last).to eq('v3')
     end
@@ -53,6 +54,7 @@ describe Grape::Middleware::Versioner::Path do
 
   context 'with mount path' do
     let(:options) { { mount_path: '/mounted', versions: [:v1] } }
+
     it 'recognizes potential version' do
       expect(subject.call('PATH_INFO' => '/mounted/v1/foo').last).to eq('v1')
     end

data/spec/grape/middleware/versioner_spec.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Middleware::Versioner do
-  let(:klass) { Grape::Middleware::Versioner }
+  let(:klass) { described_class }
 
   it 'recognizes :path' do
     expect(klass.using(:path)).to eq(Grape::Middleware::Versioner::Path)

data/spec/grape/named_api_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe 'A named API' do
   subject(:api_name) { NamedAPI.endpoints.last.options[:for].to_s }
 

data/spec/grape/parser_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Parser do
   subject { described_class }
 
@@ -26,6 +24,7 @@ describe Grape::Parser do
 
     context 'with :parsers option' do
       let(:parsers) { { customized: Class.new } }
+
       it 'includes passed :parsers values' do
         expect(subject.parsers(parsers: parsers)).to include(parsers)
       end
@@ -33,7 +32,9 @@ describe Grape::Parser do
 
     context 'with added parser by using `register` keyword' do
       let(:added_parser) { Class.new }
+
       before { subject.register :added, added_parser }
+
       it 'includes added parser' do
         expect(subject.parsers(**{})).to include(added: added_parser)
       end
@@ -54,6 +55,7 @@ describe Grape::Parser do
 
     context 'when parser is available' do
       before { subject.register :customized_json, Grape::Parser::Json }
+
       it 'returns registered parser if available' do
         expect(subject.parser_for(:customized_json)).to eq(Grape::Parser::Json)
       end

data/spec/grape/path_spec.rb

@@ -1,68 +1,66 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 module Grape
   describe Path do
     describe '#initialize' do
       it 'remembers the path' do
-        path = Path.new('/:id', anything, anything)
+        path = described_class.new('/:id', anything, anything)
         expect(path.raw_path).to eql('/:id')
       end
 
       it 'remembers the namespace' do
-        path = Path.new(anything, '/users', anything)
+        path = described_class.new(anything, '/users', anything)
         expect(path.namespace).to eql('/users')
       end
 
       it 'remebers the settings' do
-        path = Path.new(anything, anything, foo: 'bar')
+        path = described_class.new(anything, anything, foo: 'bar')
         expect(path.settings).to eql(foo: 'bar')
       end
     end
 
     describe '#mount_path' do
       it 'is nil when no mount path setting exists' do
-        path = Path.new(anything, anything, {})
+        path = described_class.new(anything, anything, {})
         expect(path.mount_path).to be_nil
       end
 
       it 'is nil when the mount path is nil' do
-        path = Path.new(anything, anything, mount_path: nil)
+        path = described_class.new(anything, anything, mount_path: nil)
         expect(path.mount_path).to be_nil
       end
 
       it 'splits the mount path' do
-        path = Path.new(anything, anything, mount_path: %w[foo bar])
+        path = described_class.new(anything, anything, mount_path: %w[foo bar])
         expect(path.mount_path).to eql(%w[foo bar])
       end
     end
 
     describe '#root_prefix' do
       it 'is nil when no root prefix setting exists' do
-        path = Path.new(anything, anything, {})
+        path = described_class.new(anything, anything, {})
         expect(path.root_prefix).to be_nil
       end
 
       it 'is nil when the mount path is nil' do
-        path = Path.new(anything, anything, root_prefix: nil)
+        path = described_class.new(anything, anything, root_prefix: nil)
         expect(path.root_prefix).to be_nil
       end
 
       it 'splits the mount path' do
-        path = Path.new(anything, anything, root_prefix: 'hello/world')
+        path = described_class.new(anything, anything, root_prefix: 'hello/world')
         expect(path.root_prefix).to eql(%w[hello world])
       end
     end
 
     describe '#uses_path_versioning?' do
       it 'is false when the version setting is nil' do
-        path = Path.new(anything, anything, version: nil)
+        path = described_class.new(anything, anything, version: nil)
         expect(path.uses_path_versioning?).to be false
       end
 
       it 'is false when the version option is header' do
-        path = Path.new(
+        path = described_class.new(
           anything,
           anything,
           version: 'v1',
@@ -73,7 +71,7 @@ module Grape
       end
 
       it 'is true when the version option is path' do
-        path = Path.new(
+        path = described_class.new(
           anything,
           anything,
           version: 'v1',
@@ -86,44 +84,44 @@ module Grape
 
     describe '#namespace?' do
       it 'is false when the namespace is nil' do
-        path = Path.new(anything, nil, anything)
-        expect(path.namespace?).to be_falsey
+        path = described_class.new(anything, nil, anything)
+        expect(path).not_to be_namespace
       end
 
       it 'is false when the namespace starts with whitespace' do
-        path = Path.new(anything, ' /foo', anything)
-        expect(path.namespace?).to be_falsey
+        path = described_class.new(anything, ' /foo', anything)
+        expect(path).not_to be_namespace
       end
 
       it 'is false when the namespace is the root path' do
-        path = Path.new(anything, '/', anything)
+        path = described_class.new(anything, '/', anything)
         expect(path.namespace?).to be false
       end
 
       it 'is true otherwise' do
-        path = Path.new(anything, '/world', anything)
+        path = described_class.new(anything, '/world', anything)
         expect(path.namespace?).to be true
       end
     end
 
     describe '#path?' do
       it 'is false when the path is nil' do
-        path = Path.new(nil, anything, anything)
-        expect(path.path?).to be_falsey
+        path = described_class.new(nil, anything, anything)
+        expect(path).not_to be_path
       end
 
       it 'is false when the path starts with whitespace' do
-        path = Path.new(' /foo', anything, anything)
-        expect(path.path?).to be_falsey
+        path = described_class.new(' /foo', anything, anything)
+        expect(path).not_to be_path
       end
 
       it 'is false when the path is the root path' do
-        path = Path.new('/', anything, anything)
+        path = described_class.new('/', anything, anything)
         expect(path.path?).to be false
       end
 
       it 'is true otherwise' do
-        path = Path.new('/hello', anything, anything)
+        path = described_class.new('/hello', anything, anything)
         expect(path.path?).to be true
       end
     end
@@ -131,24 +129,24 @@ module Grape
     describe '#path' do
       context 'mount_path' do
         it 'is not included when it is nil' do
-          path = Path.new(nil, nil, mount_path: '/foo/bar')
+          path = described_class.new(nil, nil, mount_path: '/foo/bar')
           expect(path.path).to eql '/foo/bar'
         end
 
         it 'is included when it is not nil' do
-          path = Path.new(nil, nil, {})
+          path = described_class.new(nil, nil, {})
           expect(path.path).to eql('/')
         end
       end
 
       context 'root_prefix' do
         it 'is not included when it is nil' do
-          path = Path.new(nil, nil, {})
+          path = described_class.new(nil, nil, {})
           expect(path.path).to eql('/')
         end
 
         it 'is included after the mount path' do
-          path = Path.new(
+          path = described_class.new(
             nil,
             nil,
             mount_path: '/foo',
@@ -160,7 +158,7 @@ module Grape
       end
 
       it 'uses the namespace after the mount path and root prefix' do
-        path = Path.new(
+        path = described_class.new(
           nil,
           'namespace',
           mount_path: '/foo',
@@ -171,7 +169,7 @@ module Grape
       end
 
       it 'uses the raw path after the namespace' do
-        path = Path.new(
+        path = described_class.new(
           'raw_path',
           'namespace',
           mount_path: '/foo',
@@ -185,9 +183,9 @@ module Grape
     describe '#suffix' do
       context 'when using a specific format' do
         it 'accepts specified format' do
-          path = Path.new(nil, nil, {})
-          allow(path).to receive(:uses_specific_format?) { true }
-          allow(path).to receive(:settings) { { format: :json } }
+          path = described_class.new(nil, nil, {})
+          allow(path).to receive(:uses_specific_format?).and_return(true)
+          allow(path).to receive(:settings).and_return({ format: :json })
 
           expect(path.suffix).to eql('(.json)')
         end
@@ -195,9 +193,9 @@ module Grape
 
       context 'when path versioning is used' do
         it "includes a '/'" do
-          path = Path.new(nil, nil, {})
-          allow(path).to receive(:uses_specific_format?) { false }
-          allow(path).to receive(:uses_path_versioning?) { true }
+          path = described_class.new(nil, nil, {})
+          allow(path).to receive(:uses_specific_format?).and_return(false)
+          allow(path).to receive(:uses_path_versioning?).and_return(true)
 
           expect(path.suffix).to eql('(/.:format)')
         end
@@ -205,25 +203,25 @@ 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', {})
-          allow(path).to receive(:uses_specific_format?) { false }
-          allow(path).to receive(:uses_path_versioning?) { true }
+          path = described_class.new(nil, 'namespace', {})
+          allow(path).to receive(:uses_specific_format?).and_return(false)
+          allow(path).to receive(:uses_path_versioning?).and_return(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, {})
-          allow(path).to receive(:uses_specific_format?) { false }
-          allow(path).to receive(:uses_path_versioning?) { true }
+          path = described_class.new('/path', nil, {})
+          allow(path).to receive(:uses_specific_format?).and_return(false)
+          allow(path).to receive(:uses_path_versioning?).and_return(true)
 
           expect(path.suffix).to eql('(.:format)')
         end
 
         it "includes a '/' otherwise" do
-          path = Path.new(nil, nil, {})
-          allow(path).to receive(:uses_specific_format?) { false }
-          allow(path).to receive(:uses_path_versioning?) { true }
+          path = described_class.new(nil, nil, {})
+          allow(path).to receive(:uses_specific_format?).and_return(false)
+          allow(path).to receive(:uses_path_versioning?).and_return(true)
 
           expect(path.suffix).to eql('(/.:format)')
         end
@@ -232,19 +230,19 @@ module Grape
 
     describe '#path_with_suffix' do
       it 'combines the path and suffix' do
-        path = Path.new(nil, nil, {})
-        allow(path).to receive(:path) { '/the/path' }
-        allow(path).to receive(:suffix) { 'suffix' }
+        path = described_class.new(nil, nil, {})
+        allow(path).to receive(:path).and_return('/the/path')
+        allow(path).to receive(:suffix).and_return('suffix')
 
         expect(path.path_with_suffix).to eql('/the/pathsuffix')
       end
 
       context 'when using a specific format' do
         it 'might have a suffix with specified format' do
-          path = Path.new(nil, nil, {})
-          allow(path).to receive(:path) { '/the/path' }
-          allow(path).to receive(:uses_specific_format?) { true }
-          allow(path).to receive(:settings) { { format: :json } }
+          path = described_class.new(nil, nil, {})
+          allow(path).to receive(:path).and_return('/the/path')
+          allow(path).to receive(:uses_specific_format?).and_return(true)
+          allow(path).to receive(:settings).and_return({ format: :json })
 
           expect(path.path_with_suffix).to eql('/the/path(.json)')
         end