grape 1.5.2 → 1.6.2

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

@@ -98,6 +98,7 @@ describe Grape::Validations::ParamsScope do
 
         def self.parse(value)
           raise if value == 'invalid'
+
           new(value)
         end
 
@@ -144,7 +145,7 @@ describe Grape::Validations::ParamsScope do
       get '/renaming-coerced', foo: ' there we go '
 
       expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('there we go-')
+      expect(last_response.body).to eq('-there we go')
     end
 
     it do
@@ -180,6 +181,28 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq(200)
       expect(last_response.body).to eq('{"baz":{"qux":"any"}}')
     end
+
+    it 'renaming can be defined before default' do
+      subject.params do
+        optional :foo, as: :bar, default: 'before'
+      end
+      subject.get('/rename-before-default') { declared(params)[:bar] }
+      get '/rename-before-default'
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('before')
+    end
+
+    it 'renaming can be defined after default' do
+      subject.params do
+        optional :foo, default: 'after', as: :bar
+      end
+      subject.get('/rename-after-default') { declared(params)[:bar] }
+      get '/rename-after-default'
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('after')
+    end
   end
 
   context 'array without coerce type explicitly given' do
@@ -269,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
 
@@ -277,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
@@ -501,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
@@ -517,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
@@ -562,13 +585,13 @@ 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
       subject.params do
         optional :a, as: :b
-        given b: ->(val) { val == 'x' } do
+        given a: ->(val) { val == 'x' } do
           requires :c
         end
       end
@@ -582,7 +605,7 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq 200
     end
 
-    it 'raises an error if the dependent parameter is not the renamed one' do
+    it 'does not raise if the dependent parameter is not the renamed one' do
       expect do
         subject.params do
           optional :a, as: :b
@@ -590,6 +613,17 @@ describe Grape::Validations::ParamsScope do
             requires :c
           end
         end
+      end.not_to raise_error
+    end
+
+    it 'raises an error if the dependent parameter is the renamed one' do
+      expect do
+        subject.params do
+          optional :a, as: :b
+          given :b do
+            requires :c
+          end
+        end
       end.to raise_error(Grape::Exceptions::UnknownParameter)
     end
 
@@ -753,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')
@@ -929,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
@@ -941,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
@@ -991,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