grape 1.6.0 → 1.6.1

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

data/spec/grape/request_spec.rb

@@ -21,7 +21,7 @@ module Grape
     let(:env) { default_env }
 
     let(:request) do
-      Grape::Request.new(env)
+      described_class.new(env)
     end
 
     describe '#params' do
@@ -38,7 +38,7 @@ module Grape
 
       context 'when build_params_with: Grape::Extensions::Hash::ParamBuilder is specified' do
         let(:request) do
-          Grape::Request.new(env, build_params_with: Grape::Extensions::Hash::ParamBuilder)
+          described_class.new(env, build_params_with: Grape::Extensions::Hash::ParamBuilder)
         end
 
         it 'returns symbolized params' do
@@ -65,6 +65,8 @@ module Grape
     end
 
     describe 'when the param_builder is set to Hashie' do
+      subject(:request_params) { described_class.new(env, **opts).params }
+
       before do
         Grape.configure do |config|
           config.param_builder = Grape::Extensions::Hashie::Mash::ParamBuilder
@@ -75,15 +77,15 @@ module Grape
         Grape.config.reset
       end
 
-      subject(:request_params) { Grape::Request.new(env, **opts).params }
-
       context 'when the API does not include a specific param builder' do
         let(:opts) { {} }
+
         it { is_expected.to be_a(Hashie::Mash) }
       end
 
       context 'when the API includes a specific param builder' do
         let(:opts) { { build_params_with: Grape::Extensions::Hash::ParamBuilder } }
+
         it { is_expected.to be_a(Hash) }
       end
     end

data/spec/grape/util/inheritable_setting_spec.rb

@@ -4,12 +4,12 @@ require 'spec_helper'
 module Grape
   module Util
     describe InheritableSetting do
-      before :each do
-        InheritableSetting.reset_global!
+      before do
+        described_class.reset_global!
       end
 
       let(:parent) do
-        Grape::Util::InheritableSetting.new.tap do |settings|
+        described_class.new.tap do |settings|
           settings.global[:global_thing] = :global_foo_bar
           settings.namespace[:namespace_thing] = :namespace_foo_bar
           settings.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar
@@ -20,7 +20,7 @@ module Grape
       end
 
       let(:other_parent) do
-        Grape::Util::InheritableSetting.new.tap do |settings|
+        described_class.new.tap do |settings|
           settings.namespace[:namespace_thing] = :namespace_foo_bar_other
           settings.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar_other
           settings.namespace_stackable[:namespace_stackable_thing] = :namespace_stackable_foo_bar_other
@@ -29,7 +29,7 @@ module Grape
         end
       end
 
-      before :each do
+      before do
         subject.inherit_from parent
       end
 
@@ -50,7 +50,7 @@ module Grape
           expect(parent.global[:global_thing]).to eq :global_new_foo_bar
         end
 
-        it 'should handle different parents' do
+        it 'handles different parents' do
           subject.global[:global_thing] = :global_new_foo_bar
 
           subject.inherit_from other_parent
@@ -89,7 +89,7 @@ module Grape
           expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar
         end
 
-        it 'should handle different parents' do
+        it 'handles different parents' do
           expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar
 
           subject.inherit_from other_parent

data/spec/grape/util/inheritable_values_spec.rb

@@ -4,8 +4,9 @@ require 'spec_helper'
 module Grape
   module Util
     describe InheritableValues do
-      let(:parent) { InheritableValues.new }
-      subject { InheritableValues.new(parent) }
+      subject { described_class.new(parent) }
+
+      let(:parent) { described_class.new }
 
       describe '#delete' do
         it 'deletes a key' do

data/spec/grape/util/reverse_stackable_values_spec.rb

@@ -4,9 +4,10 @@ require 'spec_helper'
 module Grape
   module Util
     describe ReverseStackableValues do
-      let(:parent) { described_class.new }
       subject { described_class.new(parent) }
 
+      let(:parent) { described_class.new }
+
       describe '#keys' do
         it 'returns all keys' do
           subject[:some_thing] = :foo_bar
@@ -102,6 +103,7 @@ module Grape
 
       describe '#clone' do
         let(:obj_cloned) { subject.clone }
+
         it 'copies all values' do
           parent = described_class.new
           child = described_class.new parent

data/spec/grape/util/stackable_values_spec.rb

@@ -4,8 +4,9 @@ require 'spec_helper'
 module Grape
   module Util
     describe StackableValues do
-      let(:parent) { StackableValues.new }
-      subject { StackableValues.new(parent) }
+      subject { described_class.new(parent) }
+
+      let(:parent) { described_class.new }
 
       describe '#keys' do
         it 'returns all keys' do
@@ -99,10 +100,11 @@ module Grape
 
       describe '#clone' do
         let(:obj_cloned) { subject.clone }
+
         it 'copies all values' do
-          parent = StackableValues.new
-          child = StackableValues.new parent
-          grandchild = StackableValues.new child
+          parent = described_class.new
+          child = described_class.new parent
+          grandchild = described_class.new child
 
           parent[:some_thing] = :foo
           child[:some_thing] = %i[bar more]

data/spec/grape/validations/instance_behaivour_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe 'Validator with instance variables' do
   let(:validator_type) do
-    Class.new(Grape::Validations::Base) do
+    Class.new(Grape::Validations::Validators::Base) do
       def validate_param!(_attr_name, _params)
         if instance_variable_defined?(:@instance_variable) && @instance_variable
           raise Grape::Exceptions::Validation.new(params: ['params'],
@@ -14,15 +14,6 @@ describe 'Validator with instance variables' do
       end
     end
   end
-
-  before do
-    Grape::Validations.register_validator('instance_validator', validator_type)
-  end
-
-  after do
-    Grape::Validations.deregister_validator('instance_validator')
-  end
-
   let(:app) do
     Class.new(Grape::API) do
       params do
@@ -35,6 +26,14 @@ describe 'Validator with instance variables' do
     end
   end
 
+  before do
+    Grape::Validations.register_validator('instance_validator', validator_type)
+  end
+
+  after do
+    Grape::Validations.deregister_validator('instance_validator')
+  end
+
   it 'passes validation every time' do
     expect(validator_type).to receive(:new).exactly(4).times.and_call_original
 

data/spec/grape/validations/multiple_attributes_iterator_spec.rb

@@ -5,6 +5,7 @@ require 'spec_helper'
 describe Grape::Validations::MultipleAttributesIterator do
   describe '#each' do
     subject(:iterator) { described_class.new(validator, scope, params) }
+
     let(:scope) { Grape::Validations::ParamsScope.new(api: Class.new(Grape::API)) }
     let(:validator) { double(attrs: %i[first second third]) }
 

data/spec/grape/validations/params_scope_spec.rb

@@ -292,7 +292,7 @@ describe Grape::Validations::ParamsScope do
         it 'does not raise an exception' do
           expect do
             subject.params { optional :numbers, type: Array[Integer], values: 0..2, default: 0..2 }
-          end.to_not raise_error
+          end.not_to raise_error
         end
       end
 
@@ -300,7 +300,7 @@ describe Grape::Validations::ParamsScope do
         it 'does not raise an exception' do
           expect do
             subject.params { optional :numbers, type: Array[Integer], values: [0, 1, 2], default: [1, 0] }
-          end.to_not raise_error
+          end.not_to raise_error
         end
       end
     end
@@ -524,7 +524,7 @@ describe Grape::Validations::ParamsScope do
             requires :c
           end
         end
-      end.to_not raise_error
+      end.not_to raise_error
     end
 
     it 'does not raise an error if when using nested given' do
@@ -540,7 +540,7 @@ describe Grape::Validations::ParamsScope do
             end
           end
         end
-      end.to_not raise_error
+      end.not_to raise_error
     end
 
     it 'allows nested dependent parameters' do
@@ -585,7 +585,7 @@ describe Grape::Validations::ParamsScope do
       body = JSON.parse(last_response.body)
 
       expect(body.keys).to include('c')
-      expect(body.keys).to_not include('b')
+      expect(body.keys).not_to include('b')
     end
 
     it 'allows renaming of dependent on parameter' do
@@ -787,7 +787,7 @@ describe Grape::Validations::ParamsScope do
       subject.get('/test') { 'ok' }
     end
 
-    it 'should pass none Hash params' do
+    it 'passes none Hash params' do
       get '/test', foos: ['']
       expect(last_response.status).to eq(200)
       expect(last_response.body).to eq('ok')
@@ -963,6 +963,7 @@ describe Grape::Validations::ParamsScope do
         expect(last_response.body).to eq('one is missing, two is missing, three is missing')
       end
     end
+
     context 'when fail_fast is defined it stops the validation' do
       it 'of other params' do
         subject.params do
@@ -975,6 +976,7 @@ describe Grape::Validations::ParamsScope do
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('one is missing')
       end
+
       it 'for a single param' do
         subject.params do
           requires :one, allow_blank: false, regexp: /[0-9]+/, fail_fast: true
@@ -1025,7 +1027,7 @@ describe Grape::Validations::ParamsScope do
         end
 
         it 'prioritizes parameter validation over group validation' do
-          expect(last_response.body).to_not include('address is empty')
+          expect(last_response.body).not_to include('address is empty')
         end
       end
     end

data/spec/grape/validations/single_attribute_iterator_spec.rb

@@ -5,6 +5,7 @@ require 'spec_helper'
 describe Grape::Validations::SingleAttributeIterator do
   describe '#each' do
     subject(:iterator) { described_class.new(validator, scope, params) }
+
     let(:scope) { Grape::Validations::ParamsScope.new(api: Class.new(Grape::API)) }
     let(:validator) { double(attrs: %i[first second]) }
 

data/spec/grape/validations/types/primitive_coercer_spec.rb

@@ -3,10 +3,10 @@
 require 'spec_helper'
 
 describe Grape::Validations::Types::PrimitiveCoercer do
-  let(:strict) { false }
-
   subject { described_class.new(type, strict) }
 
+  let(:strict) { false }
+
   describe '#call' do
     context 'BigDecimal' do
       let(:type) { BigDecimal }

data/spec/grape/validations/types_spec.rb

@@ -20,13 +20,13 @@ describe Grape::Validations::Types do
       Date, DateTime, Time
     ].each do |type|
       it "recognizes #{type} as a primitive" do
-        expect(described_class.primitive?(type)).to be_truthy
+        expect(described_class).to be_primitive(type)
       end
     end
 
     it 'identifies unknown types' do
-      expect(described_class.primitive?(Object)).to be_falsy
-      expect(described_class.primitive?(TypesSpec::FooType)).to be_falsy
+      expect(described_class).not_to be_primitive(Object)
+      expect(described_class).not_to be_primitive(TypesSpec::FooType)
     end
   end
 
@@ -35,7 +35,7 @@ describe Grape::Validations::Types do
       Hash, Array, Set
     ].each do |type|
       it "recognizes #{type} as a structure" do
-        expect(described_class.structure?(type)).to be_truthy
+        expect(described_class).to be_structure(type)
       end
     end
   end
@@ -45,22 +45,22 @@ describe Grape::Validations::Types do
       JSON, Array[JSON], File, Rack::Multipart::UploadedFile
     ].each do |type|
       it "provides special handling for #{type.inspect}" do
-        expect(described_class.special?(type)).to be_truthy
+        expect(described_class).to be_special(type)
       end
     end
   end
 
   describe '::custom?' do
     it 'returns false if the type does not respond to :parse' do
-      expect(described_class.custom?(Object)).to be_falsy
+      expect(described_class).not_to be_custom(Object)
     end
 
     it 'returns true if the type responds to :parse with one argument' do
-      expect(described_class.custom?(TypesSpec::FooType)).to be_truthy
+      expect(described_class).to be_custom(TypesSpec::FooType)
     end
 
     it 'returns false if the type\'s #parse method takes other than one argument' do
-      expect(described_class.custom?(TypesSpec::BarType)).to be_falsy
+      expect(described_class).not_to be_custom(TypesSpec::BarType)
     end
   end