grape 1.3.3 → 1.6.2

data/spec/grape/middleware/stack_spec.rb

@@ -5,19 +5,22 @@ require 'spec_helper'
 describe Grape::Middleware::Stack do
   module StackSpec
     class FooMiddleware; end
+
     class BarMiddleware; end
+
     class BlockMiddleware
       attr_reader :block
+
       def initialize(&block)
         @block = block
       end
     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
@@ -26,20 +29,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)
@@ -49,7 +52,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
@@ -58,7 +61,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
@@ -67,7 +70,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)
@@ -82,7 +85,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
@@ -91,7 +94,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)
@@ -106,7 +109,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

@@ -3,8 +3,9 @@
 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

@@ -3,8 +3,9 @@
 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 +48,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 +66,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 +91,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 +118,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 +146,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 +179,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 +188,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 +209,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 +219,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 +228,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 +238,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 +265,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

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

@@ -3,9 +3,10 @@
 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 +27,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 +41,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 +60,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

@@ -3,9 +3,10 @@
 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 +22,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 +48,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 +56,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

@@ -3,7 +3,7 @@
 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/parser_spec.rb

@@ -26,6 +26,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 +34,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 +57,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

@@ -6,63 +6,63 @@ 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 +73,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 +86,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 +131,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 +160,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 +171,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 +185,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 +195,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 +205,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 +232,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

data/spec/grape/presenters/presenter_spec.rb

@@ -19,18 +19,18 @@ module Grape
     end
 
     describe Presenter do
+      subject { PresenterSpec::Dummy.new }
+
       describe 'represent' do
         let(:object_mock) do
           Object.new
         end
 
         it 'represent object' do
-          expect(Presenter.represent(object_mock)).to eq object_mock
+          expect(described_class.represent(object_mock)).to eq object_mock
         end
       end
 
-      subject { PresenterSpec::Dummy.new }
-
       describe 'present' do
         let(:hash_mock) do
           { key: :value }
@@ -38,8 +38,9 @@ module Grape
 
         describe 'instance' do
           before do
-            subject.present hash_mock, with: Grape::Presenters::Presenter
+            subject.present hash_mock, with: described_class
           end
+
           it 'presents dummy hash' do
             expect(subject.body).to eq hash_mock
           end
@@ -56,8 +57,8 @@ module Grape
 
           describe 'instance' do
             before do
-              subject.present hash_mock1, with: Grape::Presenters::Presenter
-              subject.present hash_mock2, with: Grape::Presenters::Presenter
+              subject.present hash_mock1, with: described_class
+              subject.present hash_mock2, with: described_class
             end
 
             it 'presents both dummy presenter' do