grape 1.5.2 → 1.7.0

data/spec/grape/validations_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Validations do
   subject { Class.new(Grape::API) }
 
@@ -45,7 +43,7 @@ describe Grape::Validations do
         subject.params do
           optional :some_param
         end
-        expect(declared_params).to eq([:some_param])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq([:some_param])
       end
     end
 
@@ -65,7 +63,7 @@ describe Grape::Validations do
 
       it 'adds entity documentation to declared params' do
         define_optional_using
-        expect(declared_params).to eq(%i[field_a field_b])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq(%i[field_a field_b])
       end
 
       it 'works when field_a and field_b are not present' do
@@ -112,7 +110,7 @@ describe Grape::Validations do
         subject.params do
           requires :some_param
         end
-        expect(declared_params).to eq([:some_param])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq([:some_param])
       end
 
       it 'works when required field is present but nil' do
@@ -197,7 +195,7 @@ describe Grape::Validations do
 
       it 'adds entity documentation to declared params' do
         define_requires_all
-        expect(declared_params).to eq(%i[required_field optional_field])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq(%i[required_field optional_field])
       end
 
       it 'errors when required_field is not present' do
@@ -232,7 +230,7 @@ describe Grape::Validations do
 
       it 'adds entity documentation to declared params' do
         define_requires_none
-        expect(declared_params).to eq(%i[required_field optional_field])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq(%i[required_field optional_field])
       end
 
       it 'errors when required_field is not present' do
@@ -262,7 +260,7 @@ describe Grape::Validations do
 
         it 'adds only the entity documentation to declared params, nothing more' do
           define_requires_all
-          expect(declared_params).to eq(%i[required_field optional_field])
+          expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq(%i[required_field optional_field])
         end
       end
 
@@ -328,7 +326,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(declared_params).to eq([items: [:key]])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq([items: [:key]])
       end
     end
 
@@ -400,7 +398,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(declared_params).to eq([items: [:key]])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq([items: [:key]])
       end
     end
 
@@ -463,7 +461,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(declared_params).to eq([items: [:key]])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq([items: [:key]])
       end
     end
 
@@ -489,17 +487,24 @@ describe Grape::Validations do
     end
 
     context 'custom validator for a Hash' do
-      module ValuesSpec
-        module DateRangeValidations
-          class DateRangeValidator < Grape::Validations::Base
-            def validate_param!(attr_name, params)
-              return if params[attr_name][:from] <= params[attr_name][:to]
-              raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: "'from' must be lower or equal to 'to'")
-            end
+      let(:date_range_validator) do
+        Class.new(Grape::Validations::Validators::Base) do
+          def validate_param!(attr_name, params)
+            return if params[attr_name][:from] <= params[attr_name][:to]
+
+            raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: "'from' must be lower or equal to 'to'")
           end
         end
       end
 
+      before do
+        described_class.register_validator('date_range', date_range_validator)
+      end
+
+      after do
+        described_class.deregister_validator('date_range')
+      end
+
       before do
         subject.params do
           optional :date_range, date_range: true, type: Hash do
@@ -817,7 +822,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(declared_params).to eq([items: [:key]])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq([items: [:key]])
       end
     end
 
@@ -881,19 +886,19 @@ describe Grape::Validations do
             requires(:required_subitems, type: Array) { requires :value }
           end
         end
-        expect(declared_params).to eq([items: [:key, { optional_subitems: [:value] }, { required_subitems: [:value] }]])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq([items: [:key, { optional_subitems: [:value] }, { required_subitems: [:value] }]])
       end
 
       context <<~DESC do
         Issue occurs whenever:
         * param structure with at least three levels
-        * 1st level item is a required Array that has >1 entry with an optional item present and >1 entry with an optional item missing  
-        * 2nd level is an optional Array or Hash 
+        * 1st level item is a required Array that has >1 entry with an optional item present and >1 entry with an optional item missing#{'  '}
+        * 2nd level is an optional Array or Hash#{' '}
         * 3rd level is a required item (can be any type)
         * additional levels do not effect the issue from occuring
       DESC
 
-        it "example based off actual real world use case" do
+        it 'example based off actual real world use case' do
           subject.params do
             requires :orders, type: Array do
               requires :id, type: Integer
@@ -911,17 +916,17 @@ describe Grape::Validations do
 
           data = {
             orders: [
-              { id: 77, drugs: [{batches: [{batch_no: "A1234567"}]}]},
+              { id: 77, drugs: [{ batches: [{ batch_no: 'A1234567' }] }] },
               { id: 70 }
             ]
           }
 
           get '/validate_required_arrays_under_optional_arrays', data
-          expect(last_response.body).to eq("validate_required_arrays_under_optional_arrays works!")
+          expect(last_response.body).to eq('validate_required_arrays_under_optional_arrays works!')
           expect(last_response.status).to eq(200)
         end
 
-        it "simplest example using Array -> Array -> Hash -> String" do
+        it 'simplest example using Array -> Array -> Hash -> String' do
           subject.params do
             requires :orders, type: Array do
               requires :id, type: Integer
@@ -937,17 +942,17 @@ describe Grape::Validations do
 
           data = {
             orders: [
-              { id: 77, drugs: [{batch_no: "A1234567"}]},
+              { id: 77, drugs: [{ batch_no: 'A1234567' }] },
               { id: 70 }
             ]
           }
 
           get '/validate_required_arrays_under_optional_arrays', data
-          expect(last_response.body).to eq("validate_required_arrays_under_optional_arrays works!")
+          expect(last_response.body).to eq('validate_required_arrays_under_optional_arrays works!')
           expect(last_response.status).to eq(200)
         end
 
-        it "simplest example using Array -> Hash -> String" do
+        it 'simplest example using Array -> Hash -> String' do
           subject.params do
             requires :orders, type: Array do
               requires :id, type: Integer
@@ -963,17 +968,17 @@ describe Grape::Validations do
 
           data = {
             orders: [
-              { id: 77, drugs: {batch_no: "A1234567"}},
+              { id: 77, drugs: { batch_no: 'A1234567' } },
               { id: 70 }
             ]
           }
 
           get '/validate_required_arrays_under_optional_arrays', data
-          expect(last_response.body).to eq("validate_required_arrays_under_optional_arrays works!")
+          expect(last_response.body).to eq('validate_required_arrays_under_optional_arrays works!')
           expect(last_response.status).to eq(200)
         end
 
-        it "correctly indexes invalida data" do
+        it 'correctly indexes invalida data' do
           subject.params do
             requires :orders, type: Array do
               requires :id, type: Integer
@@ -991,16 +996,16 @@ describe Grape::Validations do
           data = {
             orders: [
               { id: 70 },
-              { id: 77, drugs: [{batch_no: "A1234567", quantity: 12}, {batch_no: "B222222"}]}
+              { id: 77, drugs: [{ batch_no: 'A1234567', quantity: 12 }, { batch_no: 'B222222' }] }
             ]
           }
 
           get '/correctly_indexes', data
-          expect(last_response.body).to eq("orders[1][drugs][1][quantity] is missing")
+          expect(last_response.body).to eq('orders[1][drugs][1][quantity] is missing')
           expect(last_response.status).to eq(400)
         end
 
-        context "multiple levels of optional and requires settings" do
+        context 'multiple levels of optional and requires settings' do
           before do
             subject.params do
               requires :top, type: Array do
@@ -1022,53 +1027,62 @@ describe Grape::Validations do
             end
           end
 
-          it "with valid data" do
+          it 'with valid data' do
             data = {
               top: [
                 { top_id: 1, middle_1: [
-                  {middle_1_id: 11}, {middle_1_id: 12, middle_2: [
-                    {middle_2_id: 121}, {middle_2_id: 122, bottom: [{bottom_id: 1221}]}]}]},
+                  { middle_1_id: 11 }, { middle_1_id: 12, middle_2: [
+                    { middle_2_id: 121 }, { middle_2_id: 122, bottom: [{ bottom_id: 1221 }] }
+                  ] }
+                ] },
                 { top_id: 2, middle_1: [
-                  {middle_1_id: 21}, {middle_1_id: 22, middle_2: [
-                  {middle_2_id: 221}]}]},
+                  { middle_1_id: 21 }, { middle_1_id: 22, middle_2: [
+                    { middle_2_id: 221 }
+                  ] }
+                ] },
                 { top_id: 3, middle_1: [
-                  {middle_1_id: 31}, {middle_1_id: 32}]},
+                  { middle_1_id: 31 }, { middle_1_id: 32 }
+                ] },
                 { top_id: 4 }
               ]
             }
 
             get '/multi_level', data
-            expect(last_response.body).to eq("multi_level works!")
+            expect(last_response.body).to eq('multi_level works!')
             expect(last_response.status).to eq(200)
           end
 
-          it "with invalid data" do
+          it 'with invalid data' do
             data = {
               top: [
                 { top_id: 1, middle_1: [
-                  {middle_1_id: 11}, {middle_1_id: 12, middle_2: [
-                  {middle_2_id: 121}, {middle_2_id: 122, bottom: [{bottom_id: nil}]}]}]},
+                  { middle_1_id: 11 }, { middle_1_id: 12, middle_2: [
+                    { middle_2_id: 121 }, { middle_2_id: 122, bottom: [{ bottom_id: nil }] }
+                  ] }
+                ] },
                 { top_id: 2, middle_1: [
-                  {middle_1_id: 21}, {middle_1_id: 22, middle_2: [{middle_2_id: nil}]}]},
+                  { middle_1_id: 21 }, { middle_1_id: 22, middle_2: [{ middle_2_id: nil }] }
+                ] },
                 { top_id: 3, middle_1: [
-                  {middle_1_id: nil}, {middle_1_id: 32}]},
+                  { middle_1_id: nil }, { middle_1_id: 32 }
+                ] },
                 { top_id: nil, missing_top_id: 4 }
               ]
             }
             # debugger
             get '/multi_level', data
-            expect(last_response.body.split(", ")).to match_array([
-              "top[3][top_id] is empty",
-              "top[2][middle_1][0][middle_1_id] is empty",
-              "top[1][middle_1][1][middle_2][0][middle_2_id] is empty",
-              "top[0][middle_1][1][middle_2][1][bottom][0][bottom_id] is empty"
-            ])
+            expect(last_response.body.split(', ')).to match_array([
+                                                                    'top[3][top_id] is empty',
+                                                                    'top[2][middle_1][0][middle_1_id] is empty',
+                                                                    'top[1][middle_1][1][middle_2][0][middle_2_id] is empty',
+                                                                    'top[0][middle_1][1][middle_2][1][bottom][0][bottom_id] is empty'
+                                                                  ])
             expect(last_response.status).to eq(400)
           end
         end
       end
 
-      it "exactly_one_of" do
+      it 'exactly_one_of' do
         subject.params do
           requires :orders, type: Array do
             requires :id, type: Integer
@@ -1086,17 +1100,17 @@ describe Grape::Validations do
 
         data = {
           orders: [
-            { id: 77, drugs: {batch_no: "A1234567"}},
+            { id: 77, drugs: { batch_no: 'A1234567' } },
             { id: 70 }
           ]
         }
 
         get '/exactly_one_of', data
-        expect(last_response.body).to eq("exactly_one_of works!")
+        expect(last_response.body).to eq('exactly_one_of works!')
         expect(last_response.status).to eq(200)
       end
 
-      it "at_least_one_of" do
+      it 'at_least_one_of' do
         subject.params do
           requires :orders, type: Array do
             requires :id, type: Integer
@@ -1114,17 +1128,17 @@ describe Grape::Validations do
 
         data = {
           orders: [
-            { id: 77, drugs: {batch_no: "A1234567"}},
+            { id: 77, drugs: { batch_no: 'A1234567' } },
             { id: 70 }
           ]
         }
 
         get '/at_least_one_of', data
-        expect(last_response.body).to eq("at_least_one_of works!")
+        expect(last_response.body).to eq('at_least_one_of works!')
         expect(last_response.status).to eq(200)
       end
 
-      it "all_or_none_of" do
+      it 'all_or_none_of' do
         subject.params do
           requires :orders, type: Array do
             requires :id, type: Integer
@@ -1142,13 +1156,13 @@ describe Grape::Validations do
 
         data = {
           orders: [
-            { id: 77, drugs: {batch_no: "A1234567", batch_id: "12"}},
+            { id: 77, drugs: { batch_no: 'A1234567', batch_id: '12' } },
             { id: 70 }
           ]
         }
 
         get '/all_or_none_of', data
-        expect(last_response.body).to eq("all_or_none_of works!")
+        expect(last_response.body).to eq('all_or_none_of works!')
         expect(last_response.status).to eq(200)
       end
     end
@@ -1173,15 +1187,24 @@ describe Grape::Validations do
     end
 
     context 'custom validation' do
-      module CustomValidations
-        class Customvalidator < Grape::Validations::Base
+      let(:custom_validator) do
+        Class.new(Grape::Validations::Validators::Base) do
           def validate_param!(attr_name, params)
             return if params[attr_name] == 'im custom'
+
             raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: 'is not custom!')
           end
         end
       end
 
+      before do
+        described_class.register_validator('customvalidator', custom_validator)
+      end
+
+      after do
+        described_class.deregister_validator('customvalidator')
+      end
+
       context 'when using optional with a custom validator' do
         before do
           subject.params do
@@ -1321,15 +1344,24 @@ describe Grape::Validations do
       end
 
       context 'when using options on param' do
-        module CustomValidations
-          class CustomvalidatorWithOptions < Grape::Validations::Base
+        let(:custom_validator_with_options) do
+          Class.new(Grape::Validations::Validators::Base) do
             def validate_param!(attr_name, params)
               return if params[attr_name] == @option[:text]
+
               raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
             end
           end
         end
 
+        before do
+          described_class.register_validator('customvalidator_with_options', custom_validator_with_options)
+        end
+
+        after do
+          described_class.deregister_validator('customvalidator_with_options')
+        end
+
         before do
           subject.params do
             optional :custom, customvalidator_with_options: { text: 'im custom with options', message: 'is not custom with options!' }
@@ -1394,14 +1426,14 @@ describe Grape::Validations do
           subject.params do
             use :pagination
           end
-          expect(declared_params).to eq %i[page per_page]
+          expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq %i[page per_page]
         end
 
         it 'by #use with multiple params' do
           subject.params do
             use :pagination, :period
           end
-          expect(declared_params).to eq %i[page per_page start_date end_date]
+          expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq %i[page per_page start_date end_date]
         end
       end
 
@@ -1424,21 +1456,25 @@ describe Grape::Validations do
             }
           end
         end
+
         it 'returns defaults' do
           get '/order'
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq({ order: :asc, order_by: :created_at }.to_json)
         end
+
         it 'overrides default value for order' do
           get '/order?order=desc'
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq({ order: :desc, order_by: :created_at }.to_json)
         end
+
         it 'overrides default value for order_by' do
           get '/order?order_by=name'
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq({ order: :asc, order_by: :name }.to_json)
         end
+
         it 'fails with invalid value' do
           get '/order?order=invalid'
           expect(last_response.status).to eq(400)
@@ -1447,23 +1483,35 @@ describe Grape::Validations do
       end
     end
 
-    context 'documentation' do
-      it 'can be included with a hash' do
-        documentation = { example: 'Joe' }
-
+    context 'with block and keyword argument' do
+      before do
+        subject.helpers do
+          params :shared_params do |type:|
+            optional :param, default: type
+          end
+        end
+        subject.format :json
         subject.params do
-          requires 'first_name', documentation: documentation
+          use :shared_params, type: 'value'
         end
-        subject.get '/' do
+        subject.get '/shared_params' do
+          {
+            param: params[:param]
+          }
         end
+      end
+
+      it 'works' do
+        get '/shared_params'
 
-        expect(subject.routes.first.params['first_name'][:documentation]).to eq(documentation)
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq({ param: 'value' }.to_json)
       end
     end
 
     context 'all or none' do
       context 'optional params' do
-        before :each do
+        before do
           subject.resource :custom_message do
             params do
               optional :beer
@@ -1476,17 +1524,20 @@ describe Grape::Validations do
             end
           end
         end
+
         context 'with a custom validation message' do
           it 'errors when any one is present' do
             get '/custom_message/all_or_none', beer: 'string'
             expect(last_response.status).to eq(400)
             expect(last_response.body).to eq 'beer, wine, juice all params are required or none is required'
           end
+
           it 'works when all params are present' do
             get '/custom_message/all_or_none', beer: 'string', wine: 'anotherstring', juice: 'anotheranotherstring'
             expect(last_response.status).to eq(200)
             expect(last_response.body).to eq 'all_or_none works!'
           end
+
           it 'works when none are present' do
             get '/custom_message/all_or_none'
             expect(last_response.status).to eq(200)
@@ -1650,7 +1701,7 @@ describe Grape::Validations do
 
     context 'exactly one of' do
       context 'params' do
-        before :each do
+        before do
           subject.resources :custom_message do
             params do
               optional :beer
@@ -1714,7 +1765,7 @@ describe Grape::Validations do
       end
 
       context 'nested params' do
-        before :each do
+        before do
           subject.params do
             requires :nested, type: Hash do
               optional :beer_nested
@@ -1756,7 +1807,7 @@ describe Grape::Validations do
 
     context 'at least one of' do
       context 'params' do
-        before :each do
+        before do
           subject.resources :custom_message do
             params do
               optional :beer
@@ -1820,7 +1871,7 @@ describe Grape::Validations do
       end
 
       context 'nested params' do
-        before :each do
+        before do
           subject.params do
             requires :nested, type: Hash do
               optional :beer
@@ -1934,4 +1985,22 @@ describe Grape::Validations do
       end
     end
   end
+
+  describe 'require_validator' do
+    subject { described_class.require_validator(short_name) }
+
+    context 'when found' do
+      let(:short_name) { :presence }
+
+      it { is_expected.to be(Grape::Validations::Validators::PresenceValidator) }
+    end
+
+    context 'when not found' do
+      let(:short_name) { :test }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(Grape::Exceptions::UnknownValidator)
+      end
+    end
+  end
 end

data/spec/integration/eager_load/eager_load_spec.rb

@@ -6,10 +6,10 @@ require 'grape'
 describe Grape do
   it 'eager_load!' do
     require 'grape/eager_load'
-    expect { Grape.eager_load! }.to_not raise_error
+    expect { described_class.eager_load! }.not_to raise_error
   end
 
   it 'compile!' do
-    expect { Class.new(Grape::API).compile! }.to_not raise_error
+    expect { Class.new(Grape::API).compile! }.not_to raise_error
   end
 end

data/spec/integration/multi_json/json_spec.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Json do
   it 'uses multi_json' do
-    expect(Grape::Json).to eq(::MultiJson)
+    expect(described_class).to eq(::MultiJson)
   end
 end

data/spec/integration/multi_xml/xml_spec.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Xml do
   it 'uses multi_xml' do
-    expect(Grape::Xml).to eq(::MultiXml)
+    expect(described_class).to eq(::MultiXml)
   end
 end