grape 0.6.1 → 0.7.0

data/spec/grape/validations/default_spec.rb

@@ -32,6 +32,38 @@ describe Grape::Validations::DefaultValidator do
         get '/message' do
           { id: params[:id], type1: params[:type1], type2: params[:type2] }
         end
+
+        params do
+          optional :random, default: -> { Random.rand }
+          optional :not_random, default: Random.rand
+        end
+        get '/numbers' do
+          { random_number: params[:random], non_random_number: params[:non_random_number] }
+        end
+
+        params do
+          # NOTE: The :foo parameter could be made required with json body
+          # params, and then an empty hash would be valid. With query parameters
+          # it must be optional if it isn't provided at all, as otherwise
+          # the validaton for the Hash itself fails because there is no such
+          # thing as an empty hash.
+          optional :foo, type: Hash do
+            optional :bar, default: 'foo-bar'
+          end
+        end
+        get '/group' do
+          { foo_bar: params[:foo][:bar] }
+        end
+
+        params do
+          optional :array, type: Array do
+            requires :name
+            optional :with_default, default: 'default'
+          end
+        end
+        get '/array' do
+          { array: params[:array] }
+        end
       end
     end
   end
@@ -63,4 +95,29 @@ describe Grape::Validations::DefaultValidator do
     last_response.status.should == 200
     last_response.body.should == { id: '1', type1: 'default-type1', type2: 'default-type2' }.to_json
   end
+
+  it 'sets lambda based defaults at the time of call' do
+    get("/numbers")
+    last_response.status.should == 200
+    before = JSON.parse(last_response.body)
+    get("/numbers")
+    last_response.status.should == 200
+    after = JSON.parse(last_response.body)
+
+    before['non_random_number'].should == after['non_random_number']
+    before['random_number'].should_not == after['random_number']
+  end
+
+  it 'set default values for optional grouped params' do
+    get('/group')
+    last_response.status.should == 200
+    last_response.body.should == { foo_bar: 'foo-bar' }.to_json
+  end
+
+  it 'sets default values for grouped arrays' do
+    get('/array?array[][name]=name&array[][name]=name2&array[][with_default]=bar2')
+    last_response.status.should == 200
+    last_response.body.should == { array: [{ name: "name", with_default: "default" }, { name: "name2", with_default: "bar2" }] }.to_json
+  end
+
 end

data/spec/grape/validations/presence_spec.rb

@@ -28,8 +28,9 @@ describe Grape::Validations::PresenceValidator do
         end
 
         params do
-          group :user do
-            requires :first_name, :last_name
+          requires :user, type: Hash do
+            requires :first_name
+            requires :last_name
           end
         end
         get '/nested' do
@@ -37,11 +38,12 @@ describe Grape::Validations::PresenceValidator do
         end
 
         params do
-          group :admin do
+          requires :admin, type: Hash do
             requires :admin_name
-            group :super do
-              group :user do
-                requires :first_name, :last_name
+            requires :super, type: Hash do
+              requires :user, type: Hash do
+                requires :first_name
+                requires :last_name
               end
             end
           end
@@ -96,7 +98,7 @@ describe Grape::Validations::PresenceValidator do
   it 'validates nested parameters' do
     get '/nested'
     last_response.status.should == 400
-    last_response.body.should == '{"error":"user[first_name] is missing"}'
+    last_response.body.should == '{"error":"user is missing, user[first_name] is missing, user[last_name] is missing"}'
 
     get '/nested', user: { first_name: "Billy" }
     last_response.status.should == 400
@@ -110,19 +112,19 @@ describe Grape::Validations::PresenceValidator do
   it 'validates triple nested parameters' do
     get '/nested_triple'
     last_response.status.should == 400
-    last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][first_name] is missing"}'
+    last_response.body.should include '{"error":"admin is missing'
 
     get '/nested_triple', user: { first_name: "Billy" }
     last_response.status.should == 400
-    last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][first_name] is missing"}'
+    last_response.body.should include '{"error":"admin is missing'
 
     get '/nested_triple', admin: { super: { first_name: "Billy" } }
     last_response.status.should == 400
-    last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][first_name] is missing"}'
+    last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user] is missing, admin[super][user][first_name] is missing, admin[super][user][last_name] is missing"}'
 
     get '/nested_triple', super: { user: { first_name: "Billy", last_name: "Bob" } }
     last_response.status.should == 400
-    last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][first_name] is missing"}'
+    last_response.body.should include '{"error":"admin is missing'
 
     get '/nested_triple', admin: { super: { user: { first_name: "Billy" } } }
     last_response.status.should == 400

data/spec/grape/validations/values_spec.rb

@@ -2,25 +2,53 @@ 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
+
+      def add_value(value)
+        @values ||= []
+        @values << value
+      end
+    end
+  end
+
   module ValidationsSpec
     module ValuesValidatorSpec
       class API < Grape::API
         default_format :json
 
         params do
-          requires :type, values: ['valid-type1', 'valid-type2', 'valid-type3']
+          requires :type, values: ValuesModel.values
         end
         get '/' do
           { type: params[:type] }
         end
 
         params do
-          optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: 'valid-type2'
+          optional :type, values: ValuesModel.values, default: 'valid-type2'
         end
         get '/default/valid' do
           { type: params[:type] }
         end
 
+        params do
+          optional :type, values: -> { ValuesModel.values }, default: 'valid-type2'
+        end
+        get '/lambda' do
+          { type: params[:type] }
+        end
+
+        params do
+          requires :type, type: Integer, desc: "An integer", values: [10, 11], default: 10
+        end
+        get '/values/coercion' do
+          { type: params[:type] }
+        end
       end
     end
   end
@@ -41,12 +69,46 @@ describe Grape::Validations::ValuesValidator do
     last_response.body.should eq({ error: "type does not have a valid value" }.to_json)
   end
 
+  it 'does not allow nil value for a parameter' do
+    get("/", type: nil)
+    last_response.status.should eq 400
+    last_response.body.should eq({ error: "type does not have a valid value" }.to_json)
+  end
+
   it 'allows a valid default value' do
     get("/default/valid")
     last_response.status.should eq 200
     last_response.body.should eq({ type: "valid-type2" }.to_json)
   end
 
+  it 'allows a proc for values' do
+    get('/lambda', type: 'valid-type1')
+    last_response.status.should eq 200
+    last_response.body.should eq({ type: "valid-type1" }.to_json)
+  end
+
+  it 'does not validate updated values without proc' do
+    ValuesModel.add_value('valid-type4')
+
+    get('/', type: 'valid-type4')
+    last_response.status.should eq 400
+    last_response.body.should eq({ error: "type does not have a valid value" }.to_json)
+  end
+
+  it 'validates against values in a proc' do
+    ValuesModel.add_value('valid-type4')
+
+    get('/lambda', type: 'valid-type4')
+    last_response.status.should eq 200
+    last_response.body.should eq({ type: "valid-type4" }.to_json)
+  end
+
+  it 'does not allow an invalid value for a parameter using lambda' do
+    get("/lambda", type: 'invalid-type')
+    last_response.status.should eq 400
+    last_response.body.should eq({ error: "type does not have a valid value" }.to_json)
+  end
+
   it 'raises IncompatibleOptionValues on an invalid default value' do
     subject = Class.new(Grape::API)
     expect {
@@ -61,4 +123,16 @@ describe Grape::Validations::ValuesValidator do
     }.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
+  it 'allows values to be a kind of the coerced type not just an instance of it' do
+    get("/values/coercion", type: 10)
+    last_response.status.should eq 200
+    last_response.body.should eq({ type: 10 }.to_json)
+  end
+
+  it 'raises IncompatibleOptionValues when values contains a value that is not a kind of the type' do
+    subject = Class.new(Grape::API)
+    expect {
+      subject.params { requires :type, values: [10.5, 11], type: Integer }
+    }.to raise_error Grape::Exceptions::IncompatibleOptionValues
+  end
 end

data/spec/grape/validations_spec.rb

@@ -78,13 +78,137 @@ describe Grape::Validations do
       end
     end
 
-    context 'required with a block' do
+    context 'requires :all using Grape::Entity documentation' do
+      def define_requires_all
+        documentation = {
+            required_field: { type: String },
+            optional_field: { type: String }
+        }
+        subject.params do
+          requires :all, except: :optional_field, using: documentation
+        end
+      end
       before do
+        define_requires_all
+        subject.get '/required' do
+          'required works'
+        end
+      end
+
+      it 'adds entity documentation to declared params' do
+        define_requires_all
+        subject.settings[:declared_params].should == [:required_field, :optional_field]
+      end
+
+      it 'errors when required_field is not present' do
+        get '/required'
+        last_response.status.should == 400
+        last_response.body.should == 'required_field is missing'
+      end
+
+      it 'works when required_field is present' do
+        get '/required', required_field: 'woof'
+        last_response.status.should == 200
+        last_response.body.should == 'required works'
+      end
+    end
+
+    context 'requires :none using Grape::Entity documentation' do
+      def define_requires_none
+        documentation = {
+            required_field: { type: String },
+            optional_field: { type: String }
+        }
+        subject.params do
+          requires :none, except: :required_field, using: documentation
+        end
+      end
+      before do
+        define_requires_none
+        subject.get '/required' do
+          'required works'
+        end
+      end
+
+      it 'adds entity documentation to declared params' do
+        define_requires_none
+        subject.settings[:declared_params].should == [:required_field, :optional_field]
+      end
+
+      it 'errors when required_field is not present' do
+        get '/required'
+        last_response.status.should == 400
+        last_response.body.should == 'required_field is missing'
+      end
+
+      it 'works when required_field is present' do
+        get '/required', required_field: 'woof'
+        last_response.status.should == 200
+        last_response.body.should == 'required works'
+      end
+    end
+
+    context 'required with an Array block' do
+      before do
+        subject.params do
+          requires :items, type: Array do
+            requires :key
+          end
+        end
+        subject.get '/required' do
+          'required works'
+        end
+      end
+
+      it 'errors when param not present' do
+        get '/required'
+        last_response.status.should == 400
+        last_response.body.should == 'items is missing'
+      end
+
+      it "errors when param is not an Array" do
+        get '/required', items: "hello"
+        last_response.status.should == 400
+        last_response.body.should == 'items is invalid, items[key] is missing'
+
+        get '/required', items: { key: 'foo' }
+        last_response.status.should == 400
+        last_response.body.should == 'items is invalid'
+      end
+
+      it "doesn't throw a missing param when param is present" do
+        get '/required', items: [{ key: 'hello' }, { key: 'world' }]
+        last_response.status.should == 200
+        last_response.body.should == 'required works'
+      end
+
+      it "doesn't allow any key in the options hash other than type" do
+        expect {
+          subject.params do
+            requires(:items, desc: 'Foo') do
+              requires :key
+            end
+          end
+        }.to raise_error ArgumentError
+      end
+
+      it 'adds to declared parameters' do
         subject.params do
           requires :items do
             requires :key
           end
         end
+        subject.settings[:declared_params].should == [items: [:key]]
+      end
+    end
+
+    context 'required with a Hash block' do
+      before do
+        subject.params do
+          requires :items, type: Hash do
+            requires :key
+          end
+        end
         subject.get '/required' do
           'required works'
         end
@@ -93,16 +217,26 @@ describe Grape::Validations do
       it 'errors when param not present' do
         get '/required'
         last_response.status.should == 400
-        last_response.body.should == 'items[key] is missing'
+        last_response.body.should == 'items is missing, items[key] is missing'
+      end
+
+      it "errors when param is not a Hash" do
+        get '/required', items: "hello"
+        last_response.status.should == 400
+        last_response.body.should == 'items is invalid, items[key] is missing'
+
+        get '/required', items: [{ key: 'foo' }]
+        last_response.status.should == 400
+        last_response.body.should == 'items is invalid'
       end
 
       it "doesn't throw a missing param when param is present" do
-        get '/required', items: [key: 'hello', key: 'world']
+        get '/required', items: { key: 'hello' }
         last_response.status.should == 200
         last_response.body.should == 'required works'
       end
 
-      it "doesn't allow more than one parameter" do
+      it "doesn't allow any key in the options hash other than type" do
         expect {
           subject.params do
             requires(:items, desc: 'Foo') do
@@ -137,7 +271,7 @@ describe Grape::Validations do
       it 'errors when param not present' do
         get '/required'
         last_response.status.should == 400
-        last_response.body.should == 'items[key] is missing'
+        last_response.body.should == 'items is missing'
       end
 
       it "doesn't throw a missing param when param is present" do
@@ -156,10 +290,206 @@ describe Grape::Validations do
       end
     end
 
-    context 'optional with a block' do
+    context 'validation within arrays' do
       before do
         subject.params do
-          optional :items do
+          group :children do
+            requires :name
+            group :parents do
+              requires :name
+            end
+          end
+        end
+        subject.get '/within_array' do
+          'within array works'
+        end
+      end
+
+      it 'can handle new scopes within child elements' do
+        get '/within_array', children: [
+          { name: 'John', parents: [{ name: 'Jane' }, { name: 'Bob' }] },
+          { name: 'Joe', parents: [{ name: 'Josie' }] }
+        ]
+        last_response.status.should == 200
+        last_response.body.should == 'within array works'
+      end
+
+      it 'errors when a parameter is not present' do
+        get '/within_array', children: [
+          { name: 'Jim', parents: [{}] },
+          { name: 'Job', parents: [{ name: 'Joy' }] }
+        ]
+        # NOTE: with body parameters in json or XML or similar this
+        # should actually fail with: children[parents][name] is missing.
+        last_response.status.should == 400
+        last_response.body.should == 'children[parents] is missing'
+      end
+
+      it 'safely handles empty arrays and blank parameters' do
+        # NOTE: with body parameters in json or XML or similar this
+        # should actually return 200, since an empty array is valid.
+        get '/within_array', children: []
+        last_response.status.should == 400
+        last_response.body.should == 'children is missing'
+        get '/within_array', children: [name: 'Jay']
+        last_response.status.should == 400
+        last_response.body.should == 'children[parents] is missing'
+      end
+
+      it "errors when param is not an Array" do
+        # NOTE: would be nicer if these just returned 'children is invalid'
+        get '/within_array', children: "hello"
+        last_response.status.should == 400
+        last_response.body.should == 'children is invalid, children[name] is missing, children[parents] is missing, children[parents] is invalid, children[parents][name] is missing'
+
+        get '/within_array', children: { name: 'foo' }
+        last_response.status.should == 400
+        last_response.body.should == 'children is invalid, children[parents] is missing'
+
+        get '/within_array', children: [name: 'Jay', parents: { name: 'Fred' }]
+        last_response.status.should == 400
+        last_response.body.should == 'children[parents] is invalid'
+      end
+    end
+
+    context 'with block param' do
+      before do
+        subject.params do
+          requires :planets do
+            requires :name
+          end
+        end
+        subject.get '/req' do
+          'within array works'
+        end
+        subject.put '/req' do
+          ''
+        end
+
+        subject.params do
+          group :stars do
+            requires :name
+          end
+        end
+        subject.get '/grp' do
+          'within array works'
+        end
+        subject.put '/grp' do
+          ''
+        end
+
+        subject.params do
+          requires :name
+          optional :moons do
+            requires :name
+          end
+        end
+        subject.get '/opt' do
+          'within array works'
+        end
+        subject.put '/opt' do
+          ''
+        end
+      end
+
+      it 'requires defaults to Array type' do
+        get '/req', planets: "Jupiter, Saturn"
+        last_response.status.should == 400
+        last_response.body.should == 'planets is invalid, planets[name] is missing'
+
+        get '/req', planets: { name: 'Jupiter' }
+        last_response.status.should == 400
+        last_response.body.should == 'planets is invalid'
+
+        get '/req', planets: [{ name: 'Venus' }, { name: 'Mars' }]
+        last_response.status.should == 200
+
+        put_with_json '/req', planets: []
+        last_response.status.should == 200
+      end
+
+      it 'optional defaults to Array type' do
+        get '/opt', name: "Jupiter", moons: "Europa, Ganymede"
+        last_response.status.should == 400
+        last_response.body.should == 'moons is invalid, moons[name] is missing'
+
+        get '/opt', name: "Jupiter", moons: { name: 'Ganymede' }
+        last_response.status.should == 400
+        last_response.body.should == 'moons is invalid'
+
+        get '/opt', name: "Jupiter", moons: [{ name: 'Io' }, { name: 'Callisto' }]
+        last_response.status.should == 200
+
+        put_with_json '/opt', name: "Venus"
+        last_response.status.should == 200
+
+        put_with_json '/opt', name: "Mercury", moons: []
+        last_response.status.should == 200
+      end
+
+      it 'group defaults to Array type' do
+        get '/grp', stars: "Sun"
+        last_response.status.should == 400
+        last_response.body.should == 'stars is invalid, stars[name] is missing'
+
+        get '/grp', stars: { name: 'Sun' }
+        last_response.status.should == 400
+        last_response.body.should == 'stars is invalid'
+
+        get '/grp', stars: [{ name: 'Sun' }]
+        last_response.status.should == 200
+
+        put_with_json '/grp', stars: []
+        last_response.status.should == 200
+      end
+    end
+
+    context 'validation within arrays with JSON' do
+      before do
+        subject.params do
+          group :children do
+            requires :name
+            group :parents do
+              requires :name
+            end
+          end
+        end
+        subject.put '/within_array' do
+          'within array works'
+        end
+      end
+
+      it 'can handle new scopes within child elements' do
+        put_with_json '/within_array', children: [
+          { name: 'John', parents: [{ name: 'Jane' }, { name: 'Bob' }] },
+          { name: 'Joe', parents: [{ name: 'Josie' }] }
+        ]
+        last_response.status.should == 200
+        last_response.body.should == 'within array works'
+      end
+
+      it 'errors when a parameter is not present' do
+        put_with_json '/within_array', children: [
+          { name: 'Jim', parents: [{}] },
+          { name: 'Job', parents: [{ name: 'Joy' }] }
+        ]
+        last_response.status.should == 400
+        last_response.body.should == 'children[parents][name] is missing'
+      end
+
+      it 'safely handles empty arrays and blank parameters' do
+        put_with_json '/within_array', children: []
+        last_response.status.should == 200
+        put_with_json '/within_array', children: [name: 'Jay']
+        last_response.status.should == 400
+        last_response.body.should == 'children[parents] is missing'
+      end
+    end
+
+    context 'optional with an Array block' do
+      before do
+        subject.params do
+          optional :items, type: Array do
             requires :key
           end
         end
@@ -175,17 +505,27 @@ describe Grape::Validations do
       end
 
       it "doesn't throw a missing param when both group and param are given" do
-        get '/optional_group', items: { key: 'foo' }
+        get '/optional_group', items: [{ key: 'foo' }]
         last_response.status.should == 200
         last_response.body.should == 'optional group works'
       end
 
       it "errors when group is present, but required param is not" do
-        get '/optional_group', items: { not_key: 'foo' }
+        get '/optional_group', items: [{ not_key: 'foo' }]
         last_response.status.should == 400
         last_response.body.should == 'items[key] is missing'
       end
 
+      it "errors when param is present but isn't an Array" do
+        get '/optional_group', items: "hello"
+        last_response.status.should == 400
+        last_response.body.should == 'items is invalid, items[key] is missing'
+
+        get '/optional_group', items: { key: 'foo' }
+        last_response.status.should == 400
+        last_response.body.should == 'items is invalid'
+      end
+
       it 'adds to declared parameters' do
         subject.params do
           optional :items do
@@ -196,13 +536,13 @@ describe Grape::Validations do
       end
     end
 
-    context 'nested optional blocks' do
+    context 'nested optional Array blocks' do
       before do
         subject.params do
-          optional :items do
+          optional :items, type: Array do
             requires :key
-            optional(:optional_subitems) { requires :value }
-            requires(:required_subitems) { requires :value }
+            optional(:optional_subitems, type: Array) { requires :value }
+            requires(:required_subitems, type: Array) { requires :value }
           end
         end
         subject.get('/nested_optional_group') { 'nested optional group works' }
@@ -215,25 +555,39 @@ describe Grape::Validations do
       end
 
       it 'does internal validations if the outer group is present' do
-        get '/nested_optional_group', items: { key: 'foo' }
+        get '/nested_optional_group', items: [{ key: 'foo' }]
         last_response.status.should == 400
-        last_response.body.should == 'items[required_subitems][value] is missing'
+        last_response.body.should == 'items[required_subitems] is missing'
 
-        get '/nested_optional_group', items: { key: 'foo', required_subitems: { value: 'bar' } }
+        get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }] }]
         last_response.status.should == 200
         last_response.body.should == 'nested optional group works'
       end
 
       it 'handles deep nesting' do
-        get '/nested_optional_group', items: { key: 'foo', required_subitems: { value: 'bar' }, optional_subitems: { not_value: 'baz' } }
+        get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }], optional_subitems: [{ not_value: 'baz' }] }]
         last_response.status.should == 400
         last_response.body.should == 'items[optional_subitems][value] is missing'
 
-        get '/nested_optional_group', items: { key: 'foo', required_subitems: { value: 'bar' }, optional_subitems: { value: 'baz' } }
+        get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }], optional_subitems: [{ value: 'baz' }] }]
         last_response.status.should == 200
         last_response.body.should == 'nested optional group works'
       end
 
+      it 'handles validation within arrays' do
+        get '/nested_optional_group', items: [{ key: 'foo' }]
+        last_response.status.should == 400
+        last_response.body.should == 'items[required_subitems] is missing'
+
+        get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }] }]
+        last_response.status.should == 200
+        last_response.body.should == 'nested optional group works'
+
+        get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }], optional_subitems: [{ not_value: 'baz' }] }]
+        last_response.status.should == 400
+        last_response.body.should == 'items[optional_subitems][value] is missing'
+      end
+
       it 'adds to declared parameters' do
         subject.params do
           optional :items do
@@ -287,11 +641,11 @@ describe Grape::Validations do
         end
 
         it 'validates when param is present' do
-          get '/optional_custom', { custom: 'im custom' }
+          get '/optional_custom', custom: 'im custom'
           last_response.status.should == 200
           last_response.body.should == 'optional with custom works!'
 
-          get '/optional_custom', { custom: 'im wrong' }
+          get '/optional_custom', custom: 'im wrong'
           last_response.status.should == 400
           last_response.body.should == 'custom is not custom!'
         end
@@ -414,5 +768,74 @@ describe Grape::Validations do
         end
       end
     end # end custom validation
+
+    context 'named' do
+      context 'can be defined' do
+        it 'in helpers' do
+          subject.helpers do
+            params :pagination do
+            end
+          end
+        end
+
+        it 'in helper module which kind of Grape::API::Helpers' do
+          module SharedParams
+            extend Grape::API::Helpers
+            params :pagination do
+            end
+          end
+          subject.helpers SharedParams
+        end
+      end
+
+      context 'can be included in usual params' do
+        before do
+          module SharedParams
+            extend Grape::API::Helpers
+            params :period do
+              optional :start_date
+              optional :end_date
+            end
+          end
+          subject.helpers SharedParams
+
+          subject.helpers do
+            params :pagination do
+              optional :page, type: Integer
+              optional :per_page, type: Integer
+            end
+          end
+        end
+
+        it 'by #use' do
+          subject.params do
+            use :pagination
+          end
+          subject.settings[:declared_params].should eq [:page, :per_page]
+        end
+
+        it 'by #use with multiple params' do
+          subject.params do
+            use :pagination, :period
+          end
+          subject.settings[:declared_params].should eq [:page, :per_page, :start_date, :end_date]
+        end
+
+      end
+    end
+
+    context 'documentation' do
+      it 'can be included with a hash' do
+        documentation = { example: 'Joe' }
+
+        subject.params do
+          requires 'first_name', documentation: documentation
+        end
+        subject.get '/' do
+        end
+
+        subject.routes.first.route_params['first_name'][:documentation].should eq(documentation)
+      end
+    end
   end
 end