grape 1.5.3 → 1.7.1

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

data/spec/grape/presenters/presenter_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 module Grape
   module Presenters
     module PresenterSpec
@@ -19,18 +17,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 +36,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 +55,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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 module Grape
   describe Request do
     let(:default_method) { 'GET' }
@@ -21,7 +19,7 @@ module Grape
     let(:env) { default_env }
 
     let(:request) do
-      Grape::Request.new(env)
+      described_class.new(env)
     end
 
     describe '#params' do
@@ -38,7 +36,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 +63,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 +75,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

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
-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 +19,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 +28,7 @@ module Grape
         end
       end
 
-      before :each do
+      before do
         subject.inherit_from parent
       end
 
@@ -50,7 +49,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 +88,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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-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 +102,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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-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 +99,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/util/strict_hash_configuration_spec.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
 module Grape
   module Util
     describe 'StrictHashConfiguration' do

data/spec/grape/validations/attributes_doc_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+describe Grape::Validations::ParamsScope::AttributesDoc do
+  shared_examples 'an optional doc attribute' do |attr|
+    it 'does not mention it' do
+      expected_opts.delete(attr)
+      validations.delete(attr)
+
+      expect(subject.first['nested[engine_age]']).not_to have_key(attr)
+    end
+  end
+
+  let(:api) { Class.new(Grape::API::Instance) }
+  let(:scope) do
+    params = nil
+    api_instance = api
+
+    # just to get nested params
+    Grape::Validations::ParamsScope.new(type: Hash, api: api) do
+      params = Grape::Validations::ParamsScope.new(element: 'nested',
+                                                   type: Hash,
+                                                   api: api_instance,
+                                                   parent: self)
+    end
+
+    params
+  end
+
+  let(:validations) do
+    {
+      presence: true,
+      desc: 'Age of...',
+      documentation: 'Age is...',
+      default: 1
+    }
+  end
+
+  let(:doc) { described_class.new(api, scope) }
+
+  describe '#extract_details' do
+    subject { doc.extract_details(validations) }
+
+    it 'cleans up doc attrs needed for documentation only' do
+      subject
+
+      expect(validations[:desc]).to be_nil
+      expect(validations[:documentation]).to be_nil
+    end
+
+    it 'does not clean up doc attrs mandatory for validators' do
+      subject
+
+      expect(validations[:presence]).not_to be_nil
+      expect(validations[:default]).not_to be_nil
+    end
+
+    it 'tells when attributes are required' do
+      subject
+
+      expect(doc.required).to be_truthy
+    end
+  end
+
+  describe '#document' do
+    subject do
+      doc.extract_details validations
+      doc.document attrs
+    end
+
+    let(:attrs) { %w[engine_age car_age] }
+    let(:valid_values) { [1, 3, 5, 8] }
+
+    let!(:expected_opts) do
+      {
+        required: true,
+        desc: validations[:desc],
+        documentation: validations[:documentation],
+        default: validations[:default],
+        type: 'Integer',
+        values: valid_values
+      }
+    end
+
+    before do
+      doc.type = Integer
+      doc.values = valid_values
+    end
+
+    context 'documentation is enabled' do
+      subject do
+        super()
+        api.namespace_stackable(:params)
+      end
+
+      it 'documents attributes' do
+        expect(subject.first).to eq('nested[engine_age]' => expected_opts,
+                                    'nested[car_age]' => expected_opts)
+      end
+
+      it_behaves_like 'an optional doc attribute', :default
+      it_behaves_like 'an optional doc attribute', :documentation
+      it_behaves_like 'an optional doc attribute', :desc
+      it_behaves_like 'an optional doc attribute', :type do
+        before { doc.type = nil }
+      end
+      it_behaves_like 'an optional doc attribute', :values do
+        before { doc.values = nil }
+      end
+
+      context 'false as a default value' do
+        before { validations[:default] = false }
+
+        it 'is still documented' do
+          doc = subject.first['nested[engine_age]']
+
+          expect(doc).to have_key(:default)
+          expect(doc[:default]).to be(false)
+        end
+      end
+
+      context 'nil as a default value' do
+        before { validations[:default] = nil }
+
+        it 'is still documented' do
+          doc = subject.first['nested[engine_age]']
+
+          expect(doc).to have_key(:default)
+          expect(doc[:default]).to be_nil
+        end
+      end
+
+      context 'the description key instead of desc' do
+        let!(:desc) { validations.delete(:desc) }
+
+        before { validations[:description] = desc }
+
+        it 'adds the given description' do
+          expect(subject.first['nested[engine_age]'][:desc]).to eq(desc)
+        end
+      end
+    end
+
+    context 'documentation is disabled' do
+      before { api.namespace_inheritable :do_not_document, true }
+
+      it 'does not document attributes' do
+        subject
+
+        expect(api.namespace_stackable(:params)).to eq([])
+      end
+    end
+  end
+end