grape 0.12.0 → 0.14.0

data/spec/grape/validations/types_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Grape::Validations::Types do
+  module TypesSpec
+    class FooType
+      def self.parse(_)
+      end
+    end
+
+    class BarType
+      def self.parse
+      end
+    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
+    ].each do |type|
+      it "recognizes #{type} as a primitive" do
+        expect(described_class.primitive?(type)).to be_truthy
+      end
+    end
+
+    it 'identifies unknown types' do
+      expect(described_class.primitive?(Object)).to be_falsy
+      expect(described_class.primitive?(TypesSpec::FooType)).to be_falsy
+    end
+  end
+
+  describe '::structure?' do
+    [
+      Hash, Array, Set
+    ].each do |type|
+      it "recognizes #{type} as a structure" do
+        expect(described_class.structure?(type)).to be_truthy
+      end
+    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
+    ].each do |type|
+      it "provides special handling for #{type.inspect}" do
+        expect(described_class.special?(type)).to be_truthy
+      end
+    end
+  end
+
+  describe '::custom?' do
+    it 'returns false if the type does not respond to :parse' do
+      expect(described_class.custom?(Object)).to be_falsy
+    end
+
+    it 'returns true if the type responds to :parse with one argument' do
+      expect(described_class.custom?(TypesSpec::FooType)).to be_truthy
+    end
+
+    it 'returns false if the type\'s #parse method takes other than one argument' do
+      expect(described_class.custom?(TypesSpec::BarType)).to be_falsy
+    end
+  end
+end

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

@@ -11,6 +11,14 @@ describe Grape::Validations::CoerceValidator do
   end
 
   describe 'coerce' do
+    module CoerceValidatorSpec
+      class User
+        include Virtus.model
+        attribute :id, Integer
+        attribute :name, String
+      end
+    end
+
     context 'i18n' do
       after :each do
         I18n.locale = :en
@@ -82,14 +90,6 @@ describe Grape::Validations::CoerceValidator do
     end
 
     context 'complex objects' do
-      module CoerceValidatorSpec
-        class User
-          include Virtus.model
-          attribute :id, Integer
-          attribute :name, String
-        end
-      end
-
       it 'error on malformed input for complex objects' do
         subject.params do
           requires :user, type: CoerceValidatorSpec::User
@@ -148,6 +148,27 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('TrueClass')
         end
+
+        it 'Array of Complex' do
+          subject.params do
+            requires :arry, coerce: Array[CoerceValidatorSpec::User]
+          end
+          subject.get '/array' do
+            params[:arry].size
+          end
+
+          get 'array', arry: [31]
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('arry is invalid')
+
+          get 'array', arry: { id: 31, name: 'Alice' }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('arry is invalid')
+
+          get 'array', arry: [{ id: 31, name: 'Alice' }]
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('1')
+        end
       end
 
       context 'Set' do
@@ -203,9 +224,9 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('TrueClass')
       end
 
-      it 'file' do
+      it 'Rack::Multipart::UploadedFile' do
         subject.params do
-          requires :file, coerce: Rack::Multipart::UploadedFile
+          requires :file, type: Rack::Multipart::UploadedFile
         end
         subject.post '/upload' do
           params[:file].filename
@@ -214,6 +235,27 @@ describe Grape::Validations::CoerceValidator do
         post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
         expect(last_response.status).to eq(201)
         expect(last_response.body).to eq(File.basename(__FILE__).to_s)
+
+        post '/upload', file: 'not a file'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('file is invalid')
+      end
+
+      it 'File' do
+        subject.params do
+          requires :file, coerce: File
+        end
+        subject.post '/upload' do
+          params[:file].filename
+        end
+
+        post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
+        expect(last_response.status).to eq(201)
+        expect(last_response.body).to eq(File.basename(__FILE__).to_s)
+
+        post '/upload', file: 'not a file'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('file is invalid')
       end
 
       it 'Nests integers' do
@@ -231,5 +273,317 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('Fixnum')
       end
     end
+
+    context 'using coerce_with' do
+      it 'uses parse where available' do
+        subject.params do
+          requires :ints, type: Array, coerce_with: JSON do
+            requires :i, type: Integer
+            requires :j
+          end
+        end
+        subject.get '/ints' do
+          ints = params[:ints].first
+          'coercion works' if ints[:i] == 1 && ints[:j] == '2'
+        end
+
+        get '/ints', ints: [{ i: 1, j: '2' }]
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('ints is invalid')
+
+        get '/ints', ints: '{"i":1,"j":"2"}'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('ints[0][i] is missing, ints[0][i] is invalid, ints[0][j] is missing')
+
+        get '/ints', ints: '[{"i":"1","j":"2"}]'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('coercion works')
+      end
+
+      it 'accepts any callable' do
+        subject.params do
+          requires :ints, type: Hash, coerce_with: JSON.method(:parse) do
+            requires :int, type: Integer, coerce_with: ->(val) { val == 'three' ? 3 : val }
+          end
+        end
+        subject.get '/ints' do
+          params[:ints][:int]
+        end
+
+        get '/ints', ints: '{"int":"3"}'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('ints[int] is invalid')
+
+        get '/ints', ints: '{"int":"three"}'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('3')
+
+        get '/ints', ints: '{"int":3}'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('3')
+      end
+
+      it 'must be supplied with :type or :coerce' do
+        expect do
+          subject.params do
+            requires :ints, coerce_with: JSON
+          end
+        end.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'first-class JSON' do
+      it 'parses objects and arrays' do
+        subject.params do
+          requires :splines, type: JSON do
+            requires :x, type: Integer, values: [1, 2, 3]
+            optional :ints, type: Array[Integer]
+            optional :obj, type: Hash do
+              optional :y
+            end
+          end
+        end
+        subject.get '/' do
+          if params[:splines].is_a? Hash
+            params[:splines][:obj][:y]
+          else
+            'arrays work' if params[:splines].any? { |s| s.key? :obj }
+          end
+        end
+
+        get '/', splines: '{"x":1,"ints":[1,2,3],"obj":{"y":"woof"}}'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('woof')
+
+        get '/', splines: '[{"x":2,"ints":[]},{"x":3,"ints":[4],"obj":{"y":"quack"}}]'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('arrays work')
+
+        get '/', splines: '{"x":4,"ints":[2]}'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('splines[x] does not have a valid value')
+
+        get '/', splines: '[{"x":1,"ints":[]},{"x":4,"ints":[]}]'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('splines[x] does not have a valid value')
+      end
+
+      it 'accepts Array[JSON] shorthand' do
+        subject.params do
+          requires :splines, type: Array[JSON] do
+            requires :x, type: Integer, values: [1, 2, 3]
+            requires :y
+          end
+        end
+        subject.get '/' do
+          params[:splines].first[:y].class.to_s
+          spline = params[:splines].first
+          "#{spline[:x].class}.#{spline[:y].class}"
+        end
+
+        get '/', splines: '{"x":"1","y":"woof"}'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Fixnum.String')
+
+        get '/', splines: '[{"x":1,"y":2},{"x":1,"y":"quack"}]'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Fixnum.Fixnum')
+
+        get '/', splines: '{"x":"4","y":"woof"}'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('splines[x] does not have a valid value')
+
+        get '/', splines: '[{"x":"4","y":"woof"}]'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('splines[x] does not have a valid value')
+      end
+
+      it "doesn't make sense using coerce_with" do
+        expect do
+          subject.params do
+            requires :bad, type: JSON, coerce_with: JSON do
+              requires :x
+            end
+          end
+        end.to raise_error(ArgumentError)
+
+        expect do
+          subject.params do
+            requires :bad, type: Array[JSON], coerce_with: JSON do
+              requires :x
+            end
+          end
+        end.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'multiple types' do
+      Boolean = Grape::API::Boolean
+
+      it 'coerces to first possible type' do
+        subject.params do
+          requires :a, types: [Boolean, Integer, String]
+        end
+        subject.get '/' do
+          params[:a].class.to_s
+        end
+
+        get '/', a: 'true'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('TrueClass')
+
+        get '/', a: '5'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Fixnum')
+
+        get '/', a: 'anything else'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('String')
+      end
+
+      it 'fails when no coercion is possible' do
+        subject.params do
+          requires :a, types: [Boolean, Integer]
+        end
+        subject.get '/' do
+          params[:a].class.to_s
+        end
+
+        get '/', a: true
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('TrueClass')
+
+        get '/', a: 'not good'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('a is invalid')
+      end
+
+      context 'for primitive collections' do
+        before do
+          subject.params do
+            optional :a, types: [String, Array[String]]
+            optional :b, types: [Array[Integer], Array[String]]
+            optional :c, type: Array[Integer, String]
+            optional :d, types: [Integer, String, Set[Integer, String]]
+          end
+          subject.get '/' do
+            (
+              params[:a] ||
+              params[:b] ||
+              params[:c] ||
+              params[:d]
+            ).inspect
+          end
+        end
+
+        it 'allows singular form declaration' do
+          get '/', a: 'one way'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('"one way"')
+
+          get '/', a: %w(the other)
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('["the", "other"]')
+
+          get '/', a: { a: 1, b: 2 }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('a is invalid')
+
+          get '/', a: [1, 2, 3]
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('["1", "2", "3"]')
+        end
+
+        it 'allows multiple collection types' do
+          get '/', b: [1, 2, 3]
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('[1, 2, 3]')
+
+          get '/', b: %w(1 2 3)
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('[1, 2, 3]')
+
+          get '/', b: [1, true, 'three']
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('["1", "true", "three"]')
+        end
+
+        it 'allows collections with multiple types' do
+          get '/', c: [1, '2', true, 'three']
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('[1, 2, "true", "three"]')
+
+          get '/', d: '1'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('1')
+
+          get '/', d: 'one'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('"one"')
+
+          get '/', d: %w(1 two)
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('#<Set: {1, "two"}>')
+        end
+      end
+
+      context 'custom coercion rules' do
+        before do
+          subject.params do
+            requires :a, types: [Boolean, String], coerce_with: (lambda do |val|
+              if val == 'yup'
+                true
+              elsif val == 'false'
+                0
+              else
+                val
+              end
+            end)
+          end
+          subject.get '/' do
+            params[:a].class.to_s
+          end
+        end
+
+        it 'respects :coerce_with' do
+          get '/', a: 'yup'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('TrueClass')
+        end
+
+        it 'still validates type' do
+          get '/', a: 'false'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('a is invalid')
+        end
+
+        it 'performs no additional coercion' do
+          get '/', a: 'true'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('String')
+        end
+      end
+
+      it 'may not be supplied together with a single type' do
+        expect do
+          subject.params do
+            requires :a, type: Integer, types: [Integer, String]
+          end
+        end.to raise_exception ArgumentError
+      end
+    end
+
+    context 'converter' do
+      it 'does not build Virtus::Attribute multiple times' do
+        subject.params do
+          requires :something, type: Array[String]
+        end
+        subject.get do
+        end
+
+        expect(Virtus::Attribute).to receive(:build).at_most(2).times.and_call_original
+        10.times { get '/' }
+      end
+    end
   end
 end

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

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
 describe Grape::Validations::ValuesValidator do
-  class ValuesModel
-    DEFAULT_VALUES = ['valid-type1', 'valid-type2', 'valid-type3']
-    class << self
-      def values
-        @values ||= []
-        [DEFAULT_VALUES + @values].flatten.uniq
-      end
+  module ValidationsSpec
+    class ValuesModel
+      DEFAULT_VALUES = ['valid-type1', 'valid-type2', 'valid-type3']
+      class << self
+        def values
+          @values ||= []
+          [DEFAULT_VALUES + @values].flatten.uniq
+        end
 
-      def add_value(value)
-        @values ||= []
-        @values << value
+        def add_value(value)
+          @values ||= []
+          @values << value
+        end
       end
     end
-  end
 
-  module ValidationsSpec
     module ValuesValidatorSpec
       class API < Grape::API
         default_format :json
@@ -56,6 +56,13 @@ describe Grape::Validations::ValuesValidator do
           { type: params[:type] }
         end
 
+        params do
+          optional :type, type: Boolean, desc: 'A boolean', values: [true]
+        end
+        get '/values/optional_boolean' do
+          { type: params[:type] }
+        end
+
         params do
           requires :type, type: Integer, desc: 'An integer', values: [10, 11], default: 10
         end
@@ -122,7 +129,7 @@ describe Grape::Validations::ValuesValidator do
   end
 
   it 'does not validate updated values without proc' do
-    ValuesModel.add_value('valid-type4')
+    ValidationsSpec::ValuesModel.add_value('valid-type4')
 
     get('/', type: 'valid-type4')
     expect(last_response.status).to eq 400
@@ -130,7 +137,7 @@ describe Grape::Validations::ValuesValidator do
   end
 
   it 'validates against values in a proc' do
-    ValuesModel.add_value('valid-type4')
+    ValidationsSpec::ValuesModel.add_value('valid-type4')
 
     get('/lambda', type: 'valid-type4')
     expect(last_response.status).to eq 200
@@ -156,7 +163,7 @@ describe Grape::Validations::ValuesValidator do
   it 'raises IncompatibleOptionValues on an invalid default value from proc' do
     subject = Class.new(Grape::API)
     expect do
-      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: ValuesModel.values.sample + '_invalid' }
+      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: ValidationsSpec::ValuesModel.values.sample + '_invalid' }
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
@@ -174,6 +181,11 @@ describe Grape::Validations::ValuesValidator do
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
+  it 'allows values to be true or false when setting the type to boolean' do
+    get('/values/optional_boolean', type: true)
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: true }.to_json)
+  end
   it 'allows values to be a kind of the coerced type not just an instance of it' do
     get('/values/coercion', type: 10)
     expect(last_response.status).to eq 200