grape 1.6.2 → 1.7.1

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

data/spec/grape/validations/instance_behaivour_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe 'Validator with instance variables' do
   let(:validator_type) do
     Class.new(Grape::Validations::Validators::Base) do

data/spec/grape/validations/multiple_attributes_iterator_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Validations::MultipleAttributesIterator do
   describe '#each' do
     subject(:iterator) { described_class.new(validator, scope, params) }

data/spec/grape/validations/params_scope_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Validations::ParamsScope do
   subject do
     Class.new(Grape::API)
@@ -11,86 +9,6 @@ describe Grape::Validations::ParamsScope do
     subject
   end
 
-  context 'setting a default' do
-    let(:documentation) { subject.routes.first.params }
-
-    context 'when the default value is truthy' do
-      before do
-        subject.params do
-          optional :int, type: Integer, default: 42
-        end
-        subject.get
-      end
-
-      it 'adds documentation about the default value' do
-        expect(documentation).to have_key('int')
-        expect(documentation['int']).to have_key(:default)
-        expect(documentation['int'][:default]).to eq(42)
-      end
-    end
-
-    context 'when the default value is false' do
-      before do
-        subject.params do
-          optional :bool, type: Grape::API::Boolean, default: false
-        end
-        subject.get
-      end
-
-      it 'adds documentation about the default value' do
-        expect(documentation).to have_key('bool')
-        expect(documentation['bool']).to have_key(:default)
-        expect(documentation['bool'][:default]).to eq(false)
-      end
-    end
-
-    context 'when the default value is nil' do
-      before do
-        subject.params do
-          optional :object, type: Object, default: nil
-        end
-        subject.get
-      end
-
-      it 'adds documentation about the default value' do
-        expect(documentation).to have_key('object')
-        expect(documentation['object']).to have_key(:default)
-        expect(documentation['object'][:default]).to eq(nil)
-      end
-    end
-  end
-
-  context 'without a default' do
-    before do
-      subject.params do
-        optional :object, type: Object
-      end
-      subject.get
-    end
-
-    it 'does not add documentation for the default value' do
-      documentation = subject.routes.first.params
-      expect(documentation).to have_key('object')
-      expect(documentation['object']).not_to have_key(:default)
-    end
-  end
-
-  context 'setting description' do
-    %i[desc description].each do |description_type|
-      it "allows setting #{description_type}" do
-        subject.params do
-          requires :int, type: Integer, description_type => 'My very nice integer'
-        end
-        subject.get '/single' do
-          'int works'
-        end
-        get '/single', int: 420
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('int works')
-      end
-    end
-  end
-
   context 'when using custom types' do
     module ParamsScopeSpec
       class CustomType
@@ -338,7 +256,7 @@ describe Grape::Validations::ParamsScope do
             requires :b
           end
         end
-      end.to raise_error Grape::Exceptions::MissingGroupTypeError
+      end.to raise_error Grape::Exceptions::MissingGroupType
 
       expect do
         subject.params do
@@ -346,7 +264,7 @@ describe Grape::Validations::ParamsScope do
             requires :b
           end
         end
-      end.to raise_error Grape::Exceptions::MissingGroupTypeError
+      end.to raise_error Grape::Exceptions::MissingGroupType
     end
 
     it 'allows Hash as type' do
@@ -406,7 +324,7 @@ describe Grape::Validations::ParamsScope do
             requires :b
           end
         end
-      end.to raise_error Grape::Exceptions::UnsupportedGroupTypeError
+      end.to raise_error Grape::Exceptions::UnsupportedGroupType
 
       expect do
         subject.params do
@@ -414,7 +332,7 @@ describe Grape::Validations::ParamsScope do
             requires :b
           end
         end
-      end.to raise_error Grape::Exceptions::UnsupportedGroupTypeError
+      end.to raise_error Grape::Exceptions::UnsupportedGroupType
     end
   end
 
@@ -746,6 +664,317 @@ describe Grape::Validations::ParamsScope do
       get '/nested', bar: { a: true, c: { b: 'yes' } }
       expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'true', 'c' => { 'b' => 'yes' } })
     end
+
+    context 'when the dependent parameter is not present #declared(params)' do
+      context 'lateral parameter' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :a
+              given :a do
+                optional :b
+              end
+            end
+            subject.get("/evaluate_given_#{evaluate_given}") { declared(params, evaluate_given: evaluate_given).to_json }
+          end
+        end
+
+        it 'evaluate_given_false' do
+          get '/evaluate_given_false', b: 'b'
+          expect(JSON.parse(last_response.body)).to eq('a' => nil, 'b' => 'b')
+        end
+
+        it 'evaluate_given_true' do
+          get '/evaluate_given_true', b: 'b'
+          expect(JSON.parse(last_response.body)).to eq('a' => nil)
+        end
+      end
+
+      context 'lateral hash parameter' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :a, values: %w[x y]
+              given a: ->(a) { a == 'x' } do
+                optional :b, type: Hash do
+                  optional :c
+                end
+                optional :e
+              end
+              given a: ->(a) { a == 'y' } do
+                optional :b, type: Hash do
+                  optional :d
+                end
+                optional :f
+              end
+            end
+            subject.get("/evaluate_given_#{evaluate_given}") { declared(params, evaluate_given: evaluate_given).to_json }
+          end
+        end
+
+        it 'evaluate_given_false' do
+          get '/evaluate_given_false', a: 'x'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'd' => nil }, 'e' => nil, 'f' => nil)
+
+          get '/evaluate_given_false', a: 'y'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => nil }, 'e' => nil, 'f' => nil)
+        end
+
+        it 'evaluate_given_true' do
+          get '/evaluate_given_true', a: 'x'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'c' => nil }, 'e' => nil)
+
+          get '/evaluate_given_true', a: 'y'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => nil }, 'f' => nil)
+        end
+      end
+
+      context 'lateral parameter within lateral hash parameter' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :a, values: %w[x y]
+              given a: ->(a) { a == 'x' } do
+                optional :b, type: Hash do
+                  optional :c
+                  given :c do
+                    optional :g
+                    optional :e, type: Hash do
+                      optional :h
+                    end
+                  end
+                end
+              end
+              given a: ->(a) { a == 'y' } do
+                optional :b, type: Hash do
+                  optional :d
+                  given :d do
+                    optional :f
+                    optional :e, type: Hash do
+                      optional :i
+                    end
+                  end
+                end
+              end
+            end
+            subject.get("/evaluate_given_#{evaluate_given}") { declared(params, evaluate_given: evaluate_given).to_json }
+          end
+        end
+
+        it 'evaluate_given_false' do
+          get '/evaluate_given_false', a: 'x'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'd' => nil, 'f' => nil, 'e' => { 'i' => nil } })
+
+          get '/evaluate_given_false', a: 'x', b: { c: 'c' }
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'd' => nil, 'f' => nil, 'e' => { 'i' => nil } })
+
+          get '/evaluate_given_false', a: 'y'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => nil, 'f' => nil, 'e' => { 'i' => nil } })
+
+          get '/evaluate_given_false', a: 'y', b: { d: 'd' }
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => 'd', 'f' => nil, 'e' => { 'i' => nil } })
+        end
+
+        it 'evaluate_given_true' do
+          get '/evaluate_given_true', a: 'x'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'c' => nil })
+
+          get '/evaluate_given_true', a: 'x', b: { c: 'c' }
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'c' => 'c', 'g' => nil, 'e' => { 'h' => nil } })
+
+          get '/evaluate_given_true', a: 'y'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => nil })
+
+          get '/evaluate_given_true', a: 'y', b: { d: 'd' }
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => 'd', 'f' => nil, 'e' => { 'i' => nil } })
+        end
+      end
+
+      context 'lateral parameter within an array param' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :array, type: Array do
+                optional :a
+                given :a do
+                  optional :b
+                end
+              end
+            end
+            subject.post("/evaluate_given_#{evaluate_given}") do
+              declared(params, evaluate_given: evaluate_given).to_json
+            end
+          end
+        end
+
+        it 'evaluate_given_false' do
+          post '/evaluate_given_false', { array: [{ b: 'b' }, { a: 'a', b: 'b' }] }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('array' => [{ 'a' => nil, 'b' => 'b' }, { 'a' => 'a', 'b' => 'b' }])
+        end
+
+        it 'evaluate_given_true' do
+          post '/evaluate_given_true', { array: [{ b: 'b' }, { a: 'a', b: 'b' }] }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('array' => [{ 'a' => nil }, { 'a' => 'a', 'b' => 'b' }])
+        end
+      end
+
+      context 'nested given parameter' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :a
+              optional :c
+              given :a do
+                given :c do
+                  optional :b
+                end
+              end
+            end
+            subject.post("/evaluate_given_#{evaluate_given}") do
+              declared(params, evaluate_given: evaluate_given).to_json
+            end
+          end
+        end
+
+        it 'evaluate_given_false' do
+          post '/evaluate_given_false', { a: 'a', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'a', 'b' => 'b', 'c' => nil)
+
+          post '/evaluate_given_false', { c: 'c', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => nil, 'b' => 'b', 'c' => 'c')
+
+          post '/evaluate_given_false', { a: 'a', c: 'c', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'a', 'b' => 'b', 'c' => 'c')
+        end
+
+        it 'evaluate_given_true' do
+          post '/evaluate_given_true', { a: 'a', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'a', 'c' => nil)
+
+          post '/evaluate_given_true', { c: 'c', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => nil, 'c' => 'c')
+
+          post '/evaluate_given_true', { a: 'a', c: 'c', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'a', 'b' => 'b', 'c' => 'c')
+        end
+      end
+
+      context 'nested given parameter within an array param' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :array, type: Array do
+                optional :a
+                optional :c
+                given :a do
+                  given :c do
+                    optional :b
+                  end
+                end
+              end
+            end
+            subject.post("/evaluate_given_#{evaluate_given}") do
+              declared(params, evaluate_given: evaluate_given).to_json
+            end
+          end
+        end
+
+        let :evaluate_given_params do
+          {
+            array: [
+              { a: 'a', b: 'b' },
+              { c: 'c', b: 'b' },
+              { a: 'a', c: 'c', b: 'b' }
+            ]
+          }
+        end
+
+        it 'evaluate_given_false' do
+          post '/evaluate_given_false', evaluate_given_params.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('array' => [{ 'a' => 'a', 'b' => 'b', 'c' => nil }, { 'a' => nil, 'b' => 'b', 'c' => 'c' }, { 'a' => 'a', 'b' => 'b', 'c' => 'c' }])
+        end
+
+        it 'evaluate_given_true' do
+          post '/evaluate_given_true', evaluate_given_params.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('array' => [{ 'a' => 'a', 'c' => nil }, { 'a' => nil, 'c' => 'c' }, { 'a' => 'a', 'b' => 'b', 'c' => 'c' }])
+        end
+      end
+
+      context 'nested given parameter within a nested given parameter within an array param' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :array, type: Array do
+                optional :a
+                optional :c
+                given :a do
+                  given :c do
+                    optional :array, type: Array do
+                      optional :a
+                      optional :c
+                      given :a do
+                        given :c do
+                          optional :b
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+            subject.post("/evaluate_given_#{evaluate_given}") do
+              declared(params, evaluate_given: evaluate_given).to_json
+            end
+          end
+        end
+
+        let :evaluate_given_params do
+          {
+            array: [{
+              a: 'a',
+              c: 'c',
+              array: [
+                { a: 'a', b: 'b' },
+                { c: 'c', b: 'b' },
+                { a: 'a', c: 'c', b: 'b' }
+              ]
+            }]
+          }
+        end
+
+        it 'evaluate_given_false' do
+          expected_response_hash = {
+            'array' => [{
+              'a' => 'a',
+              'c' => 'c',
+              'array' => [
+                { 'a' => 'a', 'b' => 'b', 'c' => nil },
+                { 'a' => nil, 'c' => 'c', 'b' => 'b' },
+                { 'a' => 'a', 'c' => 'c', 'b' => 'b' }
+              ]
+            }]
+          }
+          post '/evaluate_given_false', evaluate_given_params.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq(expected_response_hash)
+        end
+
+        it 'evaluate_given_true' do
+          expected_response_hash = {
+            'array' => [{
+              'a' => 'a',
+              'c' => 'c',
+              'array' => [
+                { 'a' => 'a', 'c' => nil },
+                { 'a' => nil, 'c' => 'c' },
+                { 'a' => 'a', 'b' => 'b', 'c' => 'c' }
+              ]
+            }]
+          }
+          post '/evaluate_given_true', evaluate_given_params.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq(expected_response_hash)
+        end
+      end
+    end
   end
 
   context 'default value in given block' do

data/spec/grape/validations/single_attribute_iterator_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Validations::SingleAttributeIterator do
   describe '#each' do
     subject(:iterator) { described_class.new(validator, scope, params) }

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Validations::Types::ArrayCoercer do
   subject { described_class.new(type) }