grape 1.3.0 → 1.5.2

data/spec/grape/validations/validators/default_spec.rb

@@ -298,4 +298,174 @@ describe Grape::Validations::DefaultValidator do
       end
     end
   end
+
+  context 'optional with nil as value' do
+    subject do
+      Class.new(Grape::API) do
+        default_format :json
+      end
+    end
+
+    def app
+      subject
+    end
+
+    context 'primitive types' do
+      [
+        [Integer, 0],
+        [Integer, 42],
+        [Float, 0.0],
+        [Float, 4.2],
+        [BigDecimal, 0.0],
+        [BigDecimal, 4.2],
+        [Numeric, 0],
+        [Numeric, 42],
+        [Date, Date.today],
+        [DateTime, DateTime.now],
+        [Time, Time.now],
+        [Time, Time.at(0)],
+        [Grape::API::Boolean, false],
+        [String, ''],
+        [String, 'non-empty-string'],
+        [Symbol, :symbol],
+        [TrueClass, true],
+        [FalseClass, false]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+
+    context 'structures types' do
+      [
+        [Hash, {}],
+        [Hash, { test: 'non-empty' }],
+        [Array, []],
+        [Array, ['non-empty']],
+        [Array[Integer], []],
+        [Set, []],
+        [Set, [1]]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+
+    context 'special types' do
+      [
+        [JSON, ''],
+        [JSON, { test: 'non-empty-string' }.to_json],
+        [Array[JSON], []],
+        [Array[JSON], [{ test: 'non-empty-string' }.to_json]],
+        [::File, ''],
+        [::File, { test: 'non-empty-string' }.to_json],
+        [Rack::Multipart::UploadedFile, ''],
+        [Rack::Multipart::UploadedFile, { test: 'non-empty-string' }.to_json]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+
+    context 'variant-member-type collections' do
+      [
+        [Array[Integer, String], [0, '']],
+        [Array[Integer, String], [42, 'non-empty-string']],
+        [[Integer, String, Array[Integer, String]], [0, '', [0, '']]],
+        [[Integer, String, Array[Integer, String]], [42, 'non-empty-string', [42, 'non-empty-string']]]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+  end
+
+  context 'array with default values and given conditions' do
+    subject do
+      Class.new(Grape::API) do
+        default_format :json
+      end
+    end
+
+    def app
+      subject
+    end
+
+    it 'applies the default values only if the conditions are met' do
+      subject.params do
+        requires :ary, type: Array do
+          requires :has_value, type: Grape::API::Boolean
+          given has_value: ->(has_value) { has_value } do
+            optional :type, type: String, values: %w[str int], default: 'str'
+            given type: ->(type) { type == 'str' } do
+              optional :str, type: String, default: 'a'
+            end
+            given type: ->(type) { type == 'int' } do
+              optional :int, type: Integer, default: 1
+            end
+          end
+        end
+      end
+      subject.post('/nested_given_and_default') { declared(self.params) }
+
+      params = {
+        ary: [
+          { has_value: false },
+          { has_value: true, type: 'int', int: 123 },
+          { has_value: true, type: 'str', str: 'b' }
+        ]
+      }
+      expected = {
+        'ary' => [
+          { 'has_value' => false, 'type' => nil,   'int' => nil, 'str' => nil },
+          { 'has_value' => true,  'type' => 'int', 'int' => 123, 'str' => nil },
+          { 'has_value' => true,  'type' => 'str', 'int' => nil, 'str' => 'b' }
+        ]
+      }
+
+      post '/nested_given_and_default', params
+      expect(last_response.status).to eq(201)
+      expect(JSON.parse(last_response.body)).to eq(expected)
+    end
+  end
 end

data/spec/grape/validations/validators/exactly_one_of_spec.rb

@@ -100,7 +100,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+          'beer,wine,grapefruit' => ['are mutually exclusive']
         )
       end
 
@@ -112,7 +112,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
           validate
           expect(last_response.status).to eq 400
           expect(JSON.parse(last_response.body)).to eq(
-            'beer,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+            'beer,wine,grapefruit' => ['are mutually exclusive']
           )
         end
       end
@@ -126,7 +126,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+          'beer,grapefruit' => ['are mutually exclusive']
         )
       end
     end
@@ -139,7 +139,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine,grapefruit' => ['you should choose one']
+          'beer,wine' => ['you should choose one']
         )
       end
     end
@@ -175,7 +175,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'item[beer],item[wine],item[grapefruit]' => ['are missing, exactly one parameter must be provided']
+          'item[beer],item[wine]' => ['are mutually exclusive']
         )
       end
     end
@@ -190,7 +190,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
           validate
           expect(last_response.status).to eq 400
           expect(JSON.parse(last_response.body)).to eq(
-            'item[beer],item[wine],item[grapefruit]' => ['are missing, exactly one parameter must be provided']
+            'item[beer],item[wine]' => ['are mutually exclusive']
           )
         end
       end
@@ -213,11 +213,11 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'items[0][beer],items[0][wine],items[0][grapefruit]' => [
-            'are missing, exactly one parameter must be provided'
+          'items[0][beer],items[0][wine]' => [
+            'are mutually exclusive'
           ],
-          'items[1][beer],items[1][wine],items[1][grapefruit]' => [
-            'are missing, exactly one parameter must be provided'
+          'items[1][wine],items[1][grapefruit]' => [
+            'are mutually exclusive'
           ]
         )
       end
@@ -231,8 +231,8 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'items[0][nested_items][0][beer],items[0][nested_items][0][wine],items[0][nested_items][0][grapefruit]' => [
-            'are missing, exactly one parameter must be provided'
+          'items[0][nested_items][0][beer],items[0][nested_items][0][wine]' => [
+            'are mutually exclusive'
           ]
         )
       end

data/spec/grape/validations/validators/except_values_spec.rb

@@ -8,6 +8,7 @@ describe Grape::Validations::ExceptValuesValidator do
       DEFAULT_EXCEPTS = ['invalid-type1', 'invalid-type2', 'invalid-type3'].freeze
       class << self
         attr_accessor :excepts
+
         def excepts
           @excepts ||= []
           [DEFAULT_EXCEPTS + @excepts].flatten.uniq

data/spec/grape/validations/validators/values_spec.rb

@@ -319,7 +319,7 @@ describe Grape::Validations::ValuesValidator do
       expect(last_response.status).to eq 200
     end
 
-    it 'allows for an optional param with a list of values' do
+    it 'accepts for an optional param with a list of values' do
       put('/optional_with_array_of_string_values', optional: nil)
       expect(last_response.status).to eq 200
     end