grape 0.13.0 → 0.14.0

data/spec/grape/path_spec.rb

@@ -82,47 +82,47 @@ module Grape
       end
     end
 
-    describe '#has_namespace?' do
+    describe '#namespace?' do
       it 'is false when the namespace is nil' do
         path = Path.new(anything, nil, anything)
-        expect(path).not_to have_namespace
+        expect(path.namespace?).to be nil
       end
 
       it 'is false when the namespace starts with whitespace' do
         path = Path.new(anything, ' /foo', anything)
-        expect(path).not_to have_namespace
+        expect(path.namespace?).to be nil
       end
 
       it 'is false when the namespace is the root path' do
         path = Path.new(anything, '/', anything)
-        expect(path).not_to have_namespace
+        expect(path.namespace?).to be false
       end
 
       it 'is true otherwise' do
         path = Path.new(anything, '/world', anything)
-        expect(path).to have_namespace
+        expect(path.namespace?).to be true
       end
     end
 
-    describe '#has_path?' do
+    describe '#path?' do
       it 'is false when the path is nil' do
         path = Path.new(nil, anything, anything)
-        expect(path).not_to have_path
+        expect(path.path?).to be nil
       end
 
       it 'is false when the path starts with whitespace' do
         path = Path.new(' /foo', anything, anything)
-        expect(path).not_to have_path
+        expect(path.path?).to be nil
       end
 
       it 'is false when the path is the root path' do
         path = Path.new('/', anything, anything)
-        expect(path).not_to have_path
+        expect(path.path?).to be false
       end
 
       it 'is true otherwise' do
         path = Path.new('/hello', anything, anything)
-        expect(path).to have_path
+        expect(path.path?).to be true
       end
     end
 

data/spec/grape/presenters/presenter_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Grape
   module Presenters
-    module InsideRouteSpec
+    module PresenterSpec
       class Dummy
         include Grape::DSL::InsideRoute
 
@@ -27,7 +27,7 @@ module Grape
         end
       end
 
-      subject { InsideRouteSpec::Dummy.new }
+      subject { PresenterSpec::Dummy.new }
 
       describe 'present' do
         let(:hash_mock) do

data/spec/grape/request_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module Grape
+  describe Request do
+    let(:default_method) { 'GET' }
+    let(:default_params) { {} }
+    let(:default_options) {
+      {
+        method: method,
+        params: params
+      }
+    }
+    let(:default_env) {
+      Rack::MockRequest.env_for('/', options)
+    }
+    let(:method) { default_method }
+    let(:params) { default_params }
+    let(:options) { default_options }
+    let(:env) { default_env }
+
+    let(:request) {
+      Grape::Request.new(env)
+    }
+
+    describe '#params' do
+      let(:params) {
+        {
+          a: '123',
+          b: 'xyz'
+        }
+      }
+
+      it 'returns params' do
+        expect(request.params).to eq('a' => '123', 'b' => 'xyz')
+      end
+
+      describe 'with rack.routing_args' do
+        let(:options) {
+          default_options.merge('rack.routing_args' => routing_args)
+        }
+        let(:routing_args) {
+          {
+            version: '123',
+            route_info: '456',
+            c: 'ccc'
+          }
+        }
+
+        it 'cuts version and route_info' do
+          expect(request.params).to eq('a' => '123', 'b' => 'xyz', 'c' => 'ccc')
+        end
+      end
+    end
+
+    describe '#headers' do
+      let(:options) {
+        default_options.merge(request_headers)
+      }
+
+      describe 'with http headers in env' do
+        let(:request_headers) {
+          {
+            'HTTP_X_GRAPE_IS_COOL' => 'yeah'
+          }
+        }
+
+        it 'cuts HTTP_ prefix and capitalizes header name words' do
+          expect(request.headers).to eq('X-Grape-Is-Cool' => 'yeah')
+        end
+      end
+
+      describe 'with non-HTTP_* stuff in env' do
+        let(:request_headers) {
+          {
+            'HTP_X_GRAPE_ENTITY_TOO' => 'but now we are testing Grape'
+          }
+        }
+
+        it 'does not include them' do
+          expect(request.headers).to eq({})
+        end
+      end
+
+      describe 'with symbolic header names' do
+        let(:request_headers) {
+          {
+            HTTP_GRAPE_LIKES_SYMBOLIC: 'it is true'
+          }
+        }
+        let(:env) {
+          default_env.merge(request_headers)
+        }
+
+        it 'converts them to string' do
+          expect(request.headers).to eq('Grape-Likes-Symbolic' => 'it is true')
+        end
+      end
+    end
+  end
+end

data/spec/grape/validations/params_scope_spec.rb

@@ -90,21 +90,23 @@ describe Grape::Validations::ParamsScope do
   end
 
   context 'when using custom types' do
-    class CustomType
-      attr_reader :value
-      def self.parse(value)
-        fail if value == 'invalid'
-        new(value)
-      end
+    module ParamsScopeSpec
+      class CustomType
+        attr_reader :value
+        def self.parse(value)
+          fail if value == 'invalid'
+          new(value)
+        end
 
-      def initialize(value)
-        @value = value
+        def initialize(value)
+          @value = value
+        end
       end
     end
 
     it 'coerces the parameter via the type\'s parse method' do
       subject.params do
-        requires :foo, type: CustomType
+        requires :foo, type: ParamsScopeSpec::CustomType
       end
       subject.get('/types') { params[:foo].value }
 

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

@@ -224,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
@@ -235,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
@@ -252,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