grape 0.19.2 → 1.0.0

data/spec/grape/extensions/param_builders/hash_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Grape::Extensions::Hash::ParamBuilder do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  describe 'in an endpoint' do
+    context '#params' do
+      before do
+        subject.params do
+          build_with Grape::Extensions::Hash::ParamBuilder
+        end
+
+        subject.get do
+          params.class
+        end
+      end
+
+      it 'should be of type Hash' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Hash')
+      end
+    end
+  end
+
+  describe 'in an api' do
+    before do
+      subject.send(:include, Grape::Extensions::Hash::ParamBuilder)
+    end
+
+    context '#params' do
+      before do
+        subject.get do
+          params.class
+        end
+      end
+
+      it 'should be Hash' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Hash')
+      end
+    end
+
+    it 'symbolizes params keys' do
+      subject.params do
+        optional :a, type: Hash do
+          optional :b, type: Hash do
+            optional :c, type: String
+          end
+          optional :d, type: Array
+        end
+      end
+
+      subject.get '/foo' do
+        [params[:a][:b][:c], params[:a][:d]]
+      end
+
+      get '/foo', 'a' => { b: { c: 'bar' }, 'd' => ['foo'] }
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('["bar", ["foo"]]')
+    end
+
+    it 'symbolizes the params' do
+      subject.params do
+        build_with Grape::Extensions::Hash::ParamBuilder
+        requires :a, type: String
+      end
+
+      subject.get '/foo' do
+        [params[:a], params['a']]
+      end
+
+      get '/foo', a: 'bar'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('["bar", nil]')
+    end
+  end
+end

data/spec/grape/extensions/param_builders/hash_with_indifferent_access_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  describe 'in an endpoint' do
+    context '#params' do
+      before do
+        subject.params do
+          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+        end
+
+        subject.get do
+          params.class
+        end
+      end
+
+      it 'should be of type Hash' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('ActiveSupport::HashWithIndifferentAccess')
+      end
+    end
+  end
+
+  describe 'in an api' do
+    before do
+      subject.send(:include, Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder)
+    end
+
+    context '#params' do
+      before do
+        subject.get do
+          params.class
+        end
+      end
+
+      it 'is a Hash' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('ActiveSupport::HashWithIndifferentAccess')
+      end
+
+      it 'parses sub hash params' do
+        subject.params do
+          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+
+          optional :a, type: Hash do
+            optional :b, type: Hash do
+              optional :c, type: String
+            end
+            optional :d, type: Array
+          end
+        end
+
+        subject.get '/foo' do
+          [params[:a]['b'][:c], params['a'][:d]]
+        end
+
+        get '/foo', a: { b: { c: 'bar' }, d: ['foo'] }
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('["bar", ["foo"]]')
+      end
+
+      it 'params are indifferent to symbol or string keys' do
+        subject.params do
+          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+          optional :a, type: Hash do
+            optional :b, type: Hash do
+              optional :c, type: String
+            end
+            optional :d, type: Array
+          end
+        end
+
+        subject.get '/foo' do
+          [params[:a]['b'][:c], params['a'][:d]]
+        end
+
+        get '/foo', 'a' => { b: { c: 'bar' }, 'd' => ['foo'] }
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('["bar", ["foo"]]')
+      end
+
+      it 'responds to string keys' do
+        subject.params do
+          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+          requires :a, type: String
+        end
+
+        subject.get '/foo' do
+          [params[:a], params['a']]
+        end
+
+        get '/foo', a: 'bar'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('["bar", "bar"]')
+      end
+    end
+  end
+end

data/spec/grape/extensions/param_builders/hashie/mash_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Grape::Extensions::Hashie::Mash::ParamBuilder do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  describe 'in an endpoint' do
+    context '#params' do
+      before do
+        subject.params do
+          build_with Grape::Extensions::Hashie::Mash::ParamBuilder
+        end
+
+        subject.get do
+          params.class
+        end
+      end
+
+      it 'should be of type Hashie::Mash' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Hashie::Mash')
+      end
+    end
+  end
+
+  describe 'in an api' do
+    before do
+      subject.send(:include, Grape::Extensions::Hashie::Mash::ParamBuilder)
+    end
+
+    context '#params' do
+      before do
+        subject.get do
+          params.class
+        end
+      end
+
+      it 'should be Hashie::Mash' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Hashie::Mash')
+      end
+    end
+
+    context 'in a nested namespace api' do
+      before do
+        subject.namespace :foo do
+          get do
+            params.class
+          end
+        end
+      end
+
+      it 'should be Hashie::Mash' do
+        get '/foo'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Hashie::Mash')
+      end
+    end
+
+    it 'is indifferent to key or symbol access' do
+      subject.params do
+        build_with Grape::Extensions::Hashie::Mash::ParamBuilder
+        requires :a, type: String
+      end
+      subject.get '/foo' do
+        [params[:a], params['a']]
+      end
+
+      get '/foo', a: 'bar'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('["bar", "bar"]')
+    end
+  end
+end

data/spec/grape/middleware/formatter_spec.rb

@@ -11,7 +11,7 @@ describe Grape::Middleware::Formatter do
     let(:body) { { 'abc' => 'def' } }
     it 'looks at the bodies for possibly serializable data' do
       _, _, bodies = *subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json')
-      bodies.each { |b| expect(b).to eq(MultiJson.dump(body)) }
+      bodies.each { |b| expect(b).to eq(::Grape::Json.dump(body)) }
     end
 
     context 'default format' do
@@ -274,7 +274,11 @@ describe Grape::Middleware::Formatter do
           'rack.input' => io,
           'CONTENT_LENGTH' => io.length
         )
-        expect(subject.env['rack.request.form_hash']['thing']['name']).to eq('Test')
+        if Object.const_defined? :MultiXml
+          expect(subject.env['rack.request.form_hash']['thing']['name']).to eq('Test')
+        else
+          expect(subject.env['rack.request.form_hash']['thing']['name']['__content__']).to eq('Test')
+        end
       end
       [Rack::Request::FORM_DATA_MEDIA_TYPES, Rack::Request::PARSEABLE_DATA_MEDIA_TYPES].flatten.each do |content_type|
         it "ignores #{content_type}" do

data/spec/grape/request_spec.rb

@@ -30,8 +30,18 @@ module Grape
         }
       end
 
-      it 'returns params' do
-        expect(request.params).to eq('a' => '123', 'b' => 'xyz')
+      it 'by default returns stringified parameter keys' do
+        expect(request.params).to eq(ActiveSupport::HashWithIndifferentAccess.new('a' => '123', 'b' => 'xyz'))
+      end
+
+      context 'when build_params_with: Grape::Extensions::Hash::ParamBuilder is specified' do
+        let(:request) do
+          Grape::Request.new(env, build_params_with: Grape::Extensions::Hash::ParamBuilder)
+        end
+
+        it 'returns symbolized params' do
+          expect(request.params).to eq(a: '123', b: 'xyz')
+        end
       end
 
       describe 'with grape.routing_args' do
@@ -47,7 +57,7 @@ module Grape
         end
 
         it 'cuts version and route_info' do
-          expect(request.params).to eq('a' => '123', 'b' => 'xyz', 'c' => 'ccc')
+          expect(request.params).to eq(ActiveSupport::HashWithIndifferentAccess.new(a: '123', b: 'xyz', c: 'ccc'))
         end
       end
     end

data/spec/grape/validations/instance_behaivour_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe 'Validator with instance variables' do
+  let(:validator_type) do
+    Class.new(Grape::Validations::Base) do
+      def validate_param!(_attr_name, _params)
+        if @instance_variable
+          raise Grape::Exceptions::Validation, params: ['params'],
+                                               message: 'This should never happen'
+        end
+        @instance_variable = true
+      end
+    end
+  end
+
+  before do
+    Grape::Validations.register_validator('instance_validator', validator_type)
+  end
+
+  after do
+    Grape::Validations.deregister_validator('instance_validator')
+  end
+
+  let(:app) do
+    Class.new(Grape::API) do
+      params do
+        optional :param_to_validate, instance_validator: true
+        optional :another_param_to_validate, instance_validator: true
+      end
+      get do
+        'noop'
+      end
+    end
+  end
+
+  it 'passes validation every time' do
+    expect(validator_type).to receive(:new).exactly(4).times.and_call_original
+
+    2.times do
+      get '/', param_to_validate: 'value', another_param_to_validate: 'value'
+      expect(last_response.status).to eq 200
+    end
+  end
+end

data/spec/grape/validations/params_scope_spec.rb

@@ -473,6 +473,29 @@ describe Grape::Validations::ParamsScope do
     end
   end
 
+  context 'when validations are dependent on a parameter within an array param' do
+    before do
+      subject.params do
+        requires :foos, type: Array do
+          optional :foo_type, :baz_type
+          given :foo_type do
+            requires :bar
+          end
+        end
+      end
+      subject.post('/test') { declared(params).to_json }
+    end
+
+    it 'applies the constraint within each value' do
+      post '/test',
+           { foos: [{ foo_type: 'a' }, { baz_type: 'c' }] }.to_json,
+           'CONTENT_TYPE' => 'application/json'
+
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('foos[0][bar] is missing')
+    end
+  end
+
   context 'when validations are dependent on a parameter with specific value' do
     # build test cases from all combinations of declarations and options
     a_decls = %i(optional requires)

data/spec/grape/validations/types_spec.rb

@@ -90,4 +90,23 @@ describe Grape::Validations::Types do
       expect(described_class.custom?(TypesSpec::BarType)).to be_falsy
     end
   end
+
+  describe '::build_coercer' do
+    it 'has internal cache variables' do
+      expect(described_class.instance_variable_get(:@__cache)).to be_a(Hash)
+      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
+      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)
+
+      described_class.instance_variable_set(:@__cache, original_cache)
+    end
+  end
 end

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

@@ -280,12 +280,49 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('TrueClass')
       end
 
+      it 'Boolean' do
+        subject.params do
+          optional :boolean, type: Boolean, default: true
+        end
+        subject.get '/boolean' do
+          params[:boolean].class
+        end
+
+        get '/boolean'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('TrueClass')
+
+        get '/boolean', boolean: true
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('TrueClass')
+
+        get '/boolean', boolean: false
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('FalseClass')
+
+        get '/boolean', boolean: 'true'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('TrueClass')
+
+        get '/boolean', boolean: 'false'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('FalseClass')
+
+        get '/boolean', boolean: 123
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('boolean is invalid')
+
+        get '/boolean', boolean: '123'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('boolean is invalid')
+      end
+
       it 'Rack::Multipart::UploadedFile' do
         subject.params do
           requires :file, type: Rack::Multipart::UploadedFile
         end
         subject.post '/upload' do
-          params[:file].filename
+          params[:file][:filename]
         end
 
         post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
@@ -302,7 +339,7 @@ describe Grape::Validations::CoerceValidator do
           requires :file, coerce: File
         end
         subject.post '/upload' do
-          params[:file].filename
+          params[:file][:filename]
         end
 
         post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
@@ -625,7 +662,7 @@ describe Grape::Validations::CoerceValidator do
 
           get '/', a: %w(the other)
           expect(last_response.status).to eq(200)
-          expect(last_response.body).to eq('#<Hashie::Array ["the", "other"]>')
+          expect(last_response.body).to eq('["the", "other"]')
 
           get '/', a: { a: 1, b: 2 }
           expect(last_response.status).to eq(400)
@@ -633,27 +670,27 @@ describe Grape::Validations::CoerceValidator do
 
           get '/', a: [1, 2, 3]
           expect(last_response.status).to eq(200)
-          expect(last_response.body).to eq('#<Hashie::Array ["1", "2", "3"]>')
+          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('#<Hashie::Array [1, 2, 3]>')
+          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('#<Hashie::Array [1, 2, 3]>')
+          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('#<Hashie::Array ["1", "true", "three"]>')
+          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('#<Hashie::Array [1, 2, "true", "three"]>')
+          expect(last_response.body).to eq('[1, 2, "true", "three"]')
 
           get '/', d: '1'
           expect(last_response.status).to eq(200)
@@ -669,6 +706,78 @@ describe Grape::Validations::CoerceValidator do
         end
       end
 
+      context 'when params is Hashie::Mash' do
+        context 'for primitive collections' do
+          before do
+            subject.params do
+              build_with Grape::Extensions::Hashie::Mash::ParamBuilder
+              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('#<Hashie::Array ["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('#<Hashie::Array ["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('#<Hashie::Array [1, 2, 3]>')
+
+            get '/', b: %w(1 2 3)
+            expect(last_response.status).to eq(200)
+            expect(last_response.body).to eq('#<Hashie::Array [1, 2, 3]>')
+
+            get '/', b: [1, true, 'three']
+            expect(last_response.status).to eq(200)
+            expect(last_response.body).to eq('#<Hashie::Array ["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('#<Hashie::Array [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
+      end
+
       context 'custom coercion rules' do
         before do
           subject.params do