grape 1.1.0 → 1.5.3

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::Types::PrimitiveCoercer do
+  let(:strict) { false }
+
+  subject { described_class.new(type, strict) }
+
+  describe '#call' do
+    context 'BigDecimal' do
+      let(:type) { BigDecimal }
+
+      it 'coerces to BigDecimal' do
+        expect(subject.call(5)).to eq(BigDecimal(5))
+      end
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Boolean' do
+      let(:type) { Grape::API::Boolean }
+
+      [true, 'true', 1].each do |val|
+        it "coerces '#{val}' to true" do
+          expect(subject.call(val)).to eq(true)
+        end
+      end
+
+      [false, 'false', 0].each do |val|
+        it "coerces '#{val}' to false" do
+          expect(subject.call(val)).to eq(false)
+        end
+      end
+
+      it 'returns an error when the given value cannot be coerced' do
+        expect(subject.call(123)).to be_instance_of(Grape::Validations::Types::InvalidValue)
+      end
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'DateTime' do
+      let(:type) { DateTime }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Float' do
+      let(:type) { Float }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Integer' do
+      let(:type) { Integer }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Numeric' do
+      let(:type) { Numeric }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Time' do
+      let(:type) { Time }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'String' do
+      let(:type) { String }
+
+      it 'coerces to String' do
+        expect(subject.call(10)).to eq('10')
+      end
+
+      it 'does not coerce an empty string to nil' do
+        expect(subject.call('')).to eq('')
+      end
+    end
+
+    context 'Symbol' do
+      let(:type) { Symbol }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'the strict mode' do
+      let(:strict) { true }
+
+      context 'Boolean' do
+        let(:type) { Grape::API::Boolean }
+
+        it 'returns an error when the given value is not Boolean' do
+          expect(subject.call(1)).to be_instance_of(Grape::Validations::Types::InvalidValue)
+        end
+
+        it 'returns a value as it is when the given value is Boolean' do
+          expect(subject.call(true)).to eq(true)
+        end
+      end
+
+      context 'BigDecimal' do
+        let(:type) { BigDecimal }
+
+        it 'returns an error when the given value is not BigDecimal' do
+          expect(subject.call(1)).to be_instance_of(Grape::Validations::Types::InvalidValue)
+        end
+
+        it 'returns a value as it is when the given value is BigDecimal' do
+          expect(subject.call(BigDecimal(0))).to eq(BigDecimal(0))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::Types::SetCoercer do
+  subject { described_class.new(type) }
+
+  describe '#call' do
+    context 'a set of primitives' do
+      let(:type) { Set[String] }
+
+      it 'coerces elements to the set' do
+        expect(subject.call([10, 20])).to eq(Set['10', '20'])
+      end
+    end
+
+    context 'a set of sets' do
+      let(:type) { Set[Set[Integer]] }
+
+      it 'coerces elements in the nested set' do
+        expect(subject.call([%w[10 20]])).to eq(Set[Set[10, 20]])
+        expect(subject.call([['10'], ['20']])).to eq(Set[Set[10], Set[20]])
+      end
+    end
+
+    context 'a set of sets of arrays' do
+      let(:type) { Set[Set[Array[Integer]]] }
+
+      it 'coerces elements in the nested set' do
+        expect(subject.call([[['10'], ['20']]])).to eq(Set[Set[Array[10], Array[20]]])
+      end
+    end
+  end
+end

data/spec/grape/validations/types_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::Types do
@@ -11,30 +13,11 @@ describe Grape::Validations::Types do
     end
   end
 
-  VirtusA = Virtus::Attribute.build(String)
-
-  module VirtusModule
-    include Virtus.module
-  end
-
-  class VirtusB
-    include VirtusModule
-  end
-
-  class VirtusC
-    include Virtus.model
-  end
-
-  MyAxiom = Axiom::Types::String.new do
-    minimum_length 1
-    maximum_length 30
-  end
-
   describe '::primitive?' do
     [
       Integer, Float, Numeric, BigDecimal,
-      Virtus::Attribute::Boolean, String, Symbol,
-      Date, DateTime, Time, Rack::Multipart::UploadedFile
+      Grape::API::Boolean, String, Symbol,
+      Date, DateTime, Time
     ].each do |type|
       it "recognizes #{type} as a primitive" do
         expect(described_class.primitive?(type)).to be_truthy
@@ -57,16 +40,6 @@ describe Grape::Validations::Types do
     end
   end
 
-  describe '::recognized?' do
-    [
-      VirtusA, VirtusB, VirtusC, MyAxiom
-    ].each do |type|
-      it "recognizes #{type}" do
-        expect(described_class.recognized?(type)).to be_truthy
-      end
-    end
-  end
-
   describe '::special?' do
     [
       JSON, Array[JSON], File, Rack::Multipart::UploadedFile
@@ -97,14 +70,14 @@ describe Grape::Validations::Types do
       expect(described_class.instance_variable_get(:@__cache_write_lock)).to be_a(Mutex)
     end
 
-    it 'caches the result of the Virtus::Attribute.build method' do
+    it 'caches the result of the build_coercer method' do
       original_cache = described_class.instance_variable_get(:@__cache)
       described_class.instance_variable_set(:@__cache, {})
 
-      coercer = 'TestCoercer'
-      expect(Virtus::Attribute).to receive(:build).once.and_return(coercer)
-      expect(described_class.build_coercer(Array[String])).to eq(coercer)
-      expect(described_class.build_coercer(Array[String])).to eq(coercer)
+      a_coercer = described_class.build_coercer(Array[String])
+      b_coercer = described_class.build_coercer(Array[String])
+
+      expect(a_coercer.object_id).to eq(b_coercer.object_id)
 
       described_class.instance_variable_set(:@__cache, original_cache)
     end

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

@@ -1,59 +1,169 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::AllOrNoneOfValidator do
   describe '#validate!' do
-    let(:scope) do
-      Struct.new(:opts) do
-        def params(arg)
-          arg
-        end
+    subject(:validate) { post path, params }
+
+    module ValidationsSpec
+      module AllOrNoneOfValidatorSpec
+        class API < Grape::API
+          rescue_from Grape::Exceptions::ValidationErrors do |e|
+            error!(e.errors.transform_keys! { |key| key.join(',') }, 400)
+          end
+
+          params do
+            optional :beer, :wine, type: Boolean
+            all_or_none_of :beer, :wine
+          end
+          post do
+          end
+
+          params do
+            optional :beer, :wine, :other, type: Boolean
+            all_or_none_of :beer, :wine
+          end
+          post 'mixed-params' do
+          end
+
+          params do
+            optional :beer, :wine, type: Boolean
+            all_or_none_of :beer, :wine, message: 'choose all or none'
+          end
+          post '/custom-message' do
+          end
+
+          params do
+            requires :item, type: Hash do
+              optional :beer, :wine, type: Boolean
+              all_or_none_of :beer, :wine
+            end
+          end
+          post '/nested-hash' do
+          end
 
-        def required?; end
+          params do
+            requires :items, type: Array do
+              optional :beer, :wine, type: Boolean
+              all_or_none_of :beer, :wine
+            end
+          end
+          post '/nested-array' do
+          end
+
+          params do
+            requires :items, type: Array do
+              requires :nested_items, type: Array do
+                optional :beer, :wine, type: Boolean
+                all_or_none_of :beer, :wine
+              end
+            end
+          end
+          post '/deeply-nested-array' do
+          end
+        end
       end
     end
-    let(:all_or_none_params) { %i[beer wine grapefruit] }
-    let(:validator) { described_class.new(all_or_none_params, {}, false, scope.new) }
+
+    def app
+      ValidationsSpec::AllOrNoneOfValidatorSpec::API
+    end
 
     context 'when all restricted params are present' do
-      let(:params) { { beer: true, wine: true, grapefruit: true } }
+      let(:path) { '/' }
+      let(:params) { { beer: true, wine: true } }
 
-      it 'does not raise a validation exception' do
-        expect(validator.validate!(params)).to eql params
+      it 'does not return a validation error' do
+        validate
+        expect(last_response.status).to eq 201
       end
 
       context 'mixed with other params' do
-        let(:mixed_params) { params.merge!(other: true, andanother: true) }
+        let(:path) { '/mixed-params' }
+        let(:params) { { beer: true, wine: true, other: true } }
 
-        it 'does not raise a validation exception' do
-          expect(validator.validate!(mixed_params)).to eql mixed_params
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
         end
       end
     end
 
-    context 'when none of the restricted params is selected' do
+    context 'when a subset of restricted params are present' do
+      let(:path) { '/' }
+      let(:params) { { beer: true } }
+
+      it 'returns a validation error' do
+        validate
+        expect(last_response.status).to eq 400
+        expect(JSON.parse(last_response.body)).to eq(
+          'beer,wine' => ['provide all or none of parameters']
+        )
+      end
+    end
+
+    context 'when custom message is specified' do
+      let(:path) { '/custom-message' }
+      let(:params) { { beer: true } }
+
+      it 'returns a validation error' do
+        validate
+        expect(last_response.status).to eq 400
+        expect(JSON.parse(last_response.body)).to eq(
+          'beer,wine' => ['choose all or none']
+        )
+      end
+    end
+
+    context 'when no restricted params are present' do
+      let(:path) { '/' }
       let(:params) { { somethingelse: true } }
 
-      it 'does not raise a validation exception' do
-        expect(validator.validate!(params)).to eql params
+      it 'does not return a validation error' do
+        validate
+        expect(last_response.status).to eq 201
       end
     end
 
-    context 'when only a subset of restricted params are present' do
-      let(:params) { { beer: true, grapefruit: true } }
+    context 'when restricted params are nested inside required hash' do
+      let(:path) { '/nested-hash' }
+      let(:params) { { item: { beer: true } } }
 
-      it 'raises a validation exception' do
-        expect do
-          validator.validate! params
-        end.to raise_error(Grape::Exceptions::Validation)
+      it 'returns a validation error with full names of the params' do
+        validate
+        expect(last_response.status).to eq 400
+        expect(JSON.parse(last_response.body)).to eq(
+          'item[beer],item[wine]' => ['provide all or none of parameters']
+        )
       end
-      context 'mixed with other params' do
-        let(:mixed_params) { params.merge!(other: true, andanother: true) }
+    end
 
-        it 'raise a validation exception' do
-          expect do
-            validator.validate! params
-          end.to raise_error(Grape::Exceptions::Validation)
-        end
+    context 'when mutually exclusive params are nested inside array' do
+      let(:path) { '/nested-array' }
+      let(:params) { { items: [{ beer: true, wine: true }, { wine: true }] } }
+
+      it 'returns a validation error with full names of the params' do
+        validate
+        expect(last_response.status).to eq 400
+        expect(JSON.parse(last_response.body)).to eq(
+          'items[1][beer],items[1][wine]' => ['provide all or none of parameters']
+        )
+      end
+    end
+
+    context 'when mutually exclusive params are deeply nested' do
+      let(:path) { '/deeply-nested-array' }
+      let(:params) { { items: [{ nested_items: [{ beer: true }] }] } }
+
+      it 'returns a validation error with full names of the params' 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]' => [
+            'provide all or none of parameters'
+          ]
+        )
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::AllowBlankValidator do