grape 1.4.0 → 1.5.0

data/lib/grape/middleware/stack.rb

@@ -6,11 +6,12 @@ module Grape
     # It allows to insert and insert after
     class Stack
       class Middleware
-        attr_reader :args, :block, :klass
+        attr_reader :args, :opts, :block, :klass
 
-        def initialize(klass, *args, &block)
+        def initialize(klass, *args, **opts, &block)
           @klass = klass
-          @args = args
+          @args  = args
+          @opts  = opts
           @block = block
         end
 
@@ -30,6 +31,18 @@ module Grape
         def inspect
           klass.to_s
         end
+
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
+          def use_in(builder)
+            block ? builder.use(klass, *args, **opts, &block) : builder.use(klass, *args, **opts)
+          end
+        else
+          def use_in(builder)
+            args  = self.args
+            args += [opts] unless opts.empty?
+            block ? builder.use(klass, *args, &block) : builder.use(klass, *args)
+          end
+        end
       end
 
       include Enumerable
@@ -90,7 +103,7 @@ module Grape
       def build(builder = Rack::Builder.new)
         others.shift(others.size).each(&method(:merge_with))
         middlewares.each do |m|
-          m.block ? builder.use(m.klass, *m.args, &m.block) : builder.use(m.klass, *m.args)
+          m.use_in(builder)
         end
         builder
       end

data/lib/grape/request.rb

@@ -8,7 +8,7 @@ module Grape
 
     alias rack_params params
 
-    def initialize(env, options = {})
+    def initialize(env, **options)
       extend options[:build_params_with] || Grape.config.param_builder
       super(env)
     end

data/lib/grape/router.rb

@@ -47,7 +47,7 @@ module Grape
 
     def associate_routes(pattern, **options)
       @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
-      @neutral_map << Grape::Router::AttributeTranslator.new(options.merge(pattern: pattern, index: @neutral_map.length))
+      @neutral_map << Grape::Router::AttributeTranslator.new(**options, pattern: pattern, index: @neutral_map.length)
     end
 
     def call(env)

data/lib/grape/router/attribute_translator.rb

@@ -23,7 +23,7 @@ module Grape
 
       ROUTER_ATTRIBUTES = %i[pattern index].freeze
 
-      def initialize(attributes = {})
+      def initialize(**attributes)
         @attributes = attributes
       end
 
@@ -37,7 +37,7 @@ module Grape
         attributes
       end
 
-      def method_missing(method_name, *args) # rubocop:disable Style/MethodMissing
+      def method_missing(method_name, *args)
         if setter?(method_name[-1])
           attributes[method_name[0..-1]] = *args
         else

data/lib/grape/util/base_inheritable.rb

@@ -9,8 +9,8 @@ module Grape
 
       # @param inherited_values [Object] An object implementing an interface
       #   of the Hash class.
-      def initialize(inherited_values = {})
-        @inherited_values = inherited_values
+      def initialize(inherited_values = nil)
+        @inherited_values = inherited_values || {}
         @new_values = {}
       end
 

data/lib/grape/util/lazy_value.rb

@@ -4,6 +4,7 @@ module Grape
   module Util
     class LazyValue
       attr_reader :access_keys
+
       def initialize(value, access_keys = [])
         @value = value
         @access_keys = access_keys

data/lib/grape/validations/params_scope.rb

@@ -54,11 +54,12 @@ module Grape
       end
 
       def meets_dependency?(params, request_params)
+        return true unless @dependent_on
+
         if @parent.present? && !@parent.meets_dependency?(@parent.params(request_params), request_params)
           return false
         end
 
-        return true unless @dependent_on
         return params.any? { |param| meets_dependency?(param, request_params) } if params.is_a?(Array)
         return false unless params.respond_to?(:with_indifferent_access)
         params = params.with_indifferent_access

data/lib/grape/validations/types/custom_type_coercer.rb

@@ -103,13 +103,25 @@ module Grape
             # passed, or if the type also implements a parse() method.
             type
           elsif type.is_a?(Enumerable)
-            ->(value) { value.respond_to?(:all?) && value.all? { |item| item.is_a? type[0] } }
+            lambda do |value|
+              value.is_a?(Enumerable) && value.all? do |val|
+                recursive_type_check(type.first, val)
+              end
+            end
           else
             # By default, do a simple type check
             ->(value) { value.is_a? type }
           end
         end
 
+        def recursive_type_check(type, value)
+          if type.is_a?(Enumerable) && value.is_a?(Enumerable)
+            value.all? { |val| recursive_type_check(type.first, val) }
+          else
+            !type.is_a?(Enumerable) && value.is_a?(type)
+          end
+        end
+
         # Enforce symbolized keys for complex types
         # by wrapping the coercion method such that
         # any Hash objects in the immediate heirarchy

data/lib/grape/validations/validators/as.rb

@@ -3,7 +3,7 @@
 module Grape
   module Validations
     class AsValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         @renamed_options = options
         super
       end

data/lib/grape/validations/validators/base.rb

@@ -13,7 +13,7 @@ module Grape
       # @param required [Boolean] attribute(s) are required or optional
       # @param scope [ParamsScope] parent scope for this Validator
       # @param opts [Hash] additional validation options
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         @attrs = Array(attrs)
         @option = options
         @required = required
@@ -47,9 +47,7 @@ module Grape
           next if !@scope.required? && empty_val
           next unless @scope.meets_dependency?(val, params)
           begin
-            if @required || val.respond_to?(:key?) && val.key?(attr_name)
-              validate_param!(attr_name, val)
-            end
+            validate_param!(attr_name, val) if @required || val.respond_to?(:key?) && val.key?(attr_name)
           rescue Grape::Exceptions::Validation => e
             array_errors << e
           end

data/lib/grape/validations/validators/default.rb

@@ -3,7 +3,7 @@
 module Grape
   module Validations
     class DefaultValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         @default = options
         super
       end
@@ -21,9 +21,8 @@ module Grape
       def validate!(params)
         attrs = SingleAttributeIterator.new(self, @scope, params)
         attrs.each do |resource_params, attr_name|
-          if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
-            validate_param!(attr_name, resource_params)
-          end
+          next unless @scope.meets_dependency?(resource_params, params)
+          validate_param!(attr_name, resource_params) if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
         end
       end
 

data/lib/grape/validations/validators/except_values.rb

@@ -3,7 +3,7 @@
 module Grape
   module Validations
     class ExceptValuesValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         @except = options.is_a?(Hash) ? options[:value] : options
         super
       end

data/lib/grape/validations/validators/values.rb

@@ -3,7 +3,7 @@
 module Grape
   module Validations
     class ValuesValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         if options.is_a?(Hash)
           @excepts = options[:except]
           @values = options[:value]

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '1.4.0'
+  VERSION = '1.5.0'
 end

data/spec/grape/api_spec.rb

@@ -1149,6 +1149,11 @@ XML
       expect(last_response.headers['Content-Type']).to eq('text/plain')
     end
 
+    it 'does not set Cache-Control' do
+      get '/foo'
+      expect(last_response.headers['Cache-Control']).to eq(nil)
+    end
+
     it 'sets content type for xml' do
       get '/foo.xml'
       expect(last_response.headers['Content-Type']).to eq('application/xml')
@@ -1595,6 +1600,11 @@ XML
       expect(subject.io).to receive(:write).with(message)
       subject.logger.info 'this will be logged'
     end
+
+    it 'does not unnecessarily retain duplicate setup blocks' do
+      subject.logger
+      expect { subject.logger }.to_not change(subject.instance_variable_get(:@setup), :size)
+    end
   end
 
   describe '.helpers' do

data/spec/grape/dsl/inside_route_spec.rb

@@ -351,6 +351,12 @@ describe Grape::Endpoint do
           expect(subject.header['Cache-Control']).to eq 'no-cache'
         end
 
+        it 'does not change Cache-Control header' do
+          subject.stream
+
+          expect(subject.header['Cache-Control']).to eq 'cache'
+        end
+
         it 'sets Content-Length header to nil' do
           subject.stream file_path
 
@@ -419,6 +425,7 @@ describe Grape::Endpoint do
 
     it 'returns default' do
       expect(subject.stream).to be nil
+      expect(subject.header['Cache-Control']).to eq nil
     end
   end
 

data/spec/grape/endpoint/declared_spec.rb

@@ -0,0 +1,590 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Endpoint do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  describe '#declared' do
+    before do
+      subject.format :json
+      subject.params do
+        requires :first
+        optional :second
+        optional :third, default: 'third-default'
+        optional :nested, type: Hash do
+          optional :fourth
+          optional :fifth
+          optional :nested_two, type: Hash do
+            optional :sixth
+            optional :nested_three, type: Hash do
+              optional :seventh
+            end
+          end
+          optional :nested_arr, type: Array do
+            optional :eighth
+          end
+          optional :empty_arr, type: Array
+          optional :empty_typed_arr, type: Array[String]
+          optional :empty_hash, type: Hash
+          optional :empty_set, type: Set
+          optional :empty_typed_set, type: Set[String]
+        end
+        optional :arr, type: Array do
+          optional :nineth
+        end
+        optional :empty_arr, type: Array
+        optional :empty_typed_arr, type: Array[String]
+        optional :empty_hash, type: Hash
+        optional :empty_set, type: Set
+        optional :empty_typed_set, type: Set[String]
+      end
+    end
+
+    context 'when params are not built with default class' do
+      it 'returns an object that corresponds with the params class - hash with indifferent access' do
+        subject.params do
+          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+        end
+        subject.get '/declared' do
+          d = declared(params, include_missing: true)
+          { declared_class: d.class.to_s }
+        end
+
+        get '/declared?first=present'
+        expect(JSON.parse(last_response.body)['declared_class']).to eq('ActiveSupport::HashWithIndifferentAccess')
+      end
+
+      it 'returns an object that corresponds with the params class - hashie mash' do
+        subject.params do
+          build_with Grape::Extensions::Hashie::Mash::ParamBuilder
+        end
+        subject.get '/declared' do
+          d = declared(params, include_missing: true)
+          { declared_class: d.class.to_s }
+        end
+
+        get '/declared?first=present'
+        expect(JSON.parse(last_response.body)['declared_class']).to eq('Hashie::Mash')
+      end
+
+      it 'returns an object that corresponds with the params class - hash' do
+        subject.params do
+          build_with Grape::Extensions::Hash::ParamBuilder
+        end
+        subject.get '/declared' do
+          d = declared(params, include_missing: true)
+          { declared_class: d.class.to_s }
+        end
+
+        get '/declared?first=present'
+        expect(JSON.parse(last_response.body)['declared_class']).to eq('Hash')
+      end
+    end
+
+    it 'should show nil for nested params if include_missing is true' do
+      subject.get '/declared' do
+        declared(params, include_missing: true)
+      end
+
+      get '/declared?first=present'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)['nested']['fourth']).to be_nil
+    end
+
+    it 'does not work in a before filter' do
+      subject.before do
+        declared(params)
+      end
+      subject.get('/declared') { declared(params) }
+
+      expect { get('/declared') }.to raise_error(
+        Grape::DSL::InsideRoute::MethodNotYetAvailable
+      )
+    end
+
+    it 'has as many keys as there are declared params' do
+      subject.get '/declared' do
+        declared(params)
+      end
+      get '/declared?first=present'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body).keys.size).to eq(10)
+    end
+
+    it 'has a optional param with default value all the time' do
+      subject.get '/declared' do
+        declared(params)
+      end
+      get '/declared?first=one'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)['third']).to eql('third-default')
+    end
+
+    it 'builds nested params' do
+      subject.get '/declared' do
+        declared(params)
+      end
+
+      get '/declared?first=present&nested[fourth]=1'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)['nested'].keys.size).to eq 9
+    end
+
+    it 'builds arrays correctly' do
+      subject.params do
+        requires :first
+        optional :second, type: Array
+      end
+      subject.post('/declared') { declared(params) }
+
+      post '/declared', first: 'present', second: ['present']
+      expect(last_response.status).to eq(201)
+
+      body = JSON.parse(last_response.body)
+      expect(body['second']).to eq(['present'])
+    end
+
+    it 'builds nested params when given array' do
+      subject.get '/dummy' do
+      end
+      subject.params do
+        requires :first
+        optional :second
+        optional :third, default: 'third-default'
+        optional :nested, type: Array do
+          optional :fourth
+        end
+      end
+      subject.get '/declared' do
+        declared(params)
+      end
+
+      get '/declared?first=present&nested[][fourth]=1&nested[][fourth]=2'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)['nested'].size).to eq 2
+    end
+
+    context 'when the param is missing and include_missing=false' do
+      before do
+        subject.get('/declared') { declared(params, include_missing: false) }
+      end
+
+      it 'sets nested objects to be nil' do
+        get '/declared?first=present'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body)['nested']).to be_nil
+      end
+    end
+
+    context 'when the param is missing and include_missing=true' do
+      before do
+        subject.get('/declared') { declared(params, include_missing: true) }
+      end
+
+      it 'sets objects with type=Hash to be a hash' do
+        get '/declared?first=present'
+        expect(last_response.status).to eq(200)
+
+        body = JSON.parse(last_response.body)
+        expect(body['empty_hash']).to eq({})
+        expect(body['nested']).to be_a(Hash)
+        expect(body['nested']['empty_hash']).to eq({})
+        expect(body['nested']['nested_two']).to be_a(Hash)
+      end
+
+      it 'sets objects with type=Set to be a set' do
+        get '/declared?first=present'
+        expect(last_response.status).to eq(200)
+
+        body = JSON.parse(last_response.body)
+        expect(['#<Set: {}>', []]).to include(body['empty_set'])
+        expect(['#<Set: {}>', []]).to include(body['empty_typed_set'])
+        expect(['#<Set: {}>', []]).to include(body['nested']['empty_set'])
+        expect(['#<Set: {}>', []]).to include(body['nested']['empty_typed_set'])
+      end
+
+      it 'sets objects with type=Array to be an array' do
+        get '/declared?first=present'
+        expect(last_response.status).to eq(200)
+
+        body = JSON.parse(last_response.body)
+        expect(body['empty_arr']).to eq([])
+        expect(body['empty_typed_arr']).to eq([])
+        expect(body['arr']).to eq([])
+        expect(body['nested']['empty_arr']).to eq([])
+        expect(body['nested']['empty_typed_arr']).to eq([])
+        expect(body['nested']['nested_arr']).to eq([])
+      end
+
+      it 'includes all declared children when type=Hash' do
+        get '/declared?first=present'
+        expect(last_response.status).to eq(200)
+
+        body = JSON.parse(last_response.body)
+        expect(body['nested'].keys).to eq(%w[fourth fifth nested_two nested_arr empty_arr empty_typed_arr empty_hash empty_set empty_typed_set])
+        expect(body['nested']['nested_two'].keys).to eq(%w[sixth nested_three])
+        expect(body['nested']['nested_two']['nested_three'].keys).to eq(%w[seventh])
+      end
+    end
+
+    it 'filters out any additional params that are given' do
+      subject.get '/declared' do
+        declared(params)
+      end
+      get '/declared?first=one&other=two'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body).key?(:other)).to eq false
+    end
+
+    it 'stringifies if that option is passed' do
+      subject.get '/declared' do
+        declared(params, stringify: true)
+      end
+
+      get '/declared?first=one&other=two'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)['first']).to eq 'one'
+    end
+
+    it 'does not include missing attributes if that option is passed' do
+      subject.get '/declared' do
+        error! 'expected nil', 400 if declared(params, include_missing: false).key?(:second)
+        ''
+      end
+
+      get '/declared?first=one&other=two'
+      expect(last_response.status).to eq(200)
+    end
+
+    it 'does not include renamed missing attributes if that option is passed' do
+      subject.params do
+        optional :renamed_original, as: :renamed
+      end
+      subject.get '/declared' do
+        error! 'expected nil', 400 if declared(params, include_missing: false).key?(:renamed)
+        ''
+      end
+
+      get '/declared?first=one&other=two'
+      expect(last_response.status).to eq(200)
+    end
+
+    it 'includes attributes with value that evaluates to false' do
+      subject.params do
+        requires :first
+        optional :boolean
+      end
+
+      subject.post '/declared' do
+        error!('expected false', 400) if declared(params, include_missing: false)[:boolean] != false
+        ''
+      end
+
+      post '/declared', ::Grape::Json.dump(first: 'one', boolean: false), 'CONTENT_TYPE' => 'application/json'
+      expect(last_response.status).to eq(201)
+    end
+
+    it 'includes attributes with value that evaluates to nil' do
+      subject.params do
+        requires :first
+        optional :second
+      end
+
+      subject.post '/declared' do
+        error!('expected nil', 400) unless declared(params, include_missing: false)[:second].nil?
+        ''
+      end
+
+      post '/declared', ::Grape::Json.dump(first: 'one', second: nil), 'CONTENT_TYPE' => 'application/json'
+      expect(last_response.status).to eq(201)
+    end
+
+    it 'includes missing attributes with defaults when there are nested hashes' do
+      subject.get '/dummy' do
+      end
+
+      subject.params do
+        requires :first
+        optional :second
+        optional :third, default: nil
+        optional :nested, type: Hash do
+          optional :fourth, default: nil
+          optional :fifth, default: nil
+          requires :nested_nested, type: Hash do
+            optional :sixth, default: 'sixth-default'
+            optional :seven, default: nil
+          end
+        end
+      end
+
+      subject.get '/declared' do
+        declared(params, include_missing: false)
+      end
+
+      get '/declared?first=present&nested[fourth]=&nested[nested_nested][sixth]=sixth'
+      json = JSON.parse(last_response.body)
+      expect(last_response.status).to eq(200)
+      expect(json['first']).to eq 'present'
+      expect(json['nested'].keys).to eq %w[fourth fifth nested_nested]
+      expect(json['nested']['fourth']).to eq ''
+      expect(json['nested']['nested_nested'].keys).to eq %w[sixth seven]
+      expect(json['nested']['nested_nested']['sixth']).to eq 'sixth'
+    end
+
+    it 'does not include missing attributes when there are nested hashes' do
+      subject.get '/dummy' do
+      end
+
+      subject.params do
+        requires :first
+        optional :second
+        optional :third
+        optional :nested, type: Hash do
+          optional :fourth
+          optional :fifth
+        end
+      end
+
+      subject.get '/declared' do
+        declared(params, include_missing: false)
+      end
+
+      get '/declared?first=present&nested[fourth]=4'
+      json = JSON.parse(last_response.body)
+      expect(last_response.status).to eq(200)
+      expect(json['first']).to eq 'present'
+      expect(json['nested'].keys).to eq %w[fourth]
+      expect(json['nested']['fourth']).to eq '4'
+    end
+  end
+
+  describe '#declared; call from child namespace' do
+    before do
+      subject.format :json
+      subject.namespace :parent do
+        params do
+          requires :parent_name, type: String
+        end
+
+        namespace ':parent_name' do
+          params do
+            requires :child_name, type: String
+            requires :child_age, type: Integer
+          end
+
+          namespace ':child_name' do
+            params do
+              requires :grandchild_name, type: String
+            end
+
+            get ':grandchild_name' do
+              {
+                'params' => params,
+                'without_parent_namespaces' => declared(params, include_parent_namespaces: false),
+                'with_parent_namespaces' => declared(params, include_parent_namespaces: true)
+              }
+            end
+          end
+        end
+      end
+
+      get '/parent/foo/bar/baz', child_age: 5, extra: 'hello'
+    end
+
+    let(:parsed_response) { JSON.parse(last_response.body, symbolize_names: true) }
+
+    it { expect(last_response.status).to eq 200 }
+
+    context 'with include_parent_namespaces: false' do
+      it 'returns declared parameters only from current namespace' do
+        expect(parsed_response[:without_parent_namespaces]).to eq(
+          grandchild_name: 'baz'
+        )
+      end
+    end
+
+    context 'with include_parent_namespaces: true' do
+      it 'returns declared parameters from every parent namespace' do
+        expect(parsed_response[:with_parent_namespaces]).to eq(
+          parent_name: 'foo',
+          child_name: 'bar',
+          grandchild_name: 'baz',
+          child_age: 5
+        )
+      end
+    end
+
+    context 'without declaration' do
+      it 'returns all requested parameters' do
+        expect(parsed_response[:params]).to eq(
+          parent_name: 'foo',
+          child_name: 'bar',
+          grandchild_name: 'baz',
+          child_age: 5,
+          extra: 'hello'
+        )
+      end
+    end
+  end
+
+  describe '#declared; from a nested mounted endpoint' do
+    before do
+      doubly_mounted = Class.new(Grape::API)
+      doubly_mounted.namespace :more do
+        params do
+          requires :y, type: Integer
+        end
+        route_param :y do
+          get do
+            {
+              params: params,
+              declared_params: declared(params)
+            }
+          end
+        end
+      end
+
+      mounted = Class.new(Grape::API)
+      mounted.namespace :another do
+        params do
+          requires :mount_space, type: Integer
+        end
+        route_param :mount_space do
+          mount doubly_mounted
+        end
+      end
+
+      subject.format :json
+      subject.namespace :something do
+        params do
+          requires :id, type: Integer
+        end
+        resource ':id' do
+          mount mounted
+        end
+      end
+    end
+
+    it 'can access parent attributes' do
+      get '/something/123/another/456/more/789'
+      expect(last_response.status).to eq 200
+      json = JSON.parse(last_response.body, symbolize_names: true)
+
+      # test all three levels of params
+      expect(json[:declared_params][:y]).to eq 789
+      expect(json[:declared_params][:mount_space]).to eq 456
+      expect(json[:declared_params][:id]).to eq 123
+    end
+  end
+
+  describe '#declared; mixed nesting' do
+    before do
+      subject.format :json
+      subject.resource :users do
+        route_param :id, type: Integer, desc: 'ID desc' do
+          # Adding this causes route_setting(:declared_params) to be nil for the
+          # get block in namespace 'foo' below
+          get do
+          end
+
+          namespace 'foo' do
+            get do
+              {
+                params: params,
+                declared_params: declared(params),
+                declared_params_no_parent: declared(params, include_parent_namespaces: false)
+              }
+            end
+          end
+        end
+      end
+    end
+
+    it 'can access parent route_param' do
+      get '/users/123/foo', bar: 'bar'
+      expect(last_response.status).to eq 200
+      json = JSON.parse(last_response.body, symbolize_names: true)
+
+      expect(json[:declared_params][:id]).to eq 123
+      expect(json[:declared_params_no_parent][:id]).to eq nil
+    end
+  end
+
+  describe '#declared; with multiple route_param' do
+    before do
+      mounted = Class.new(Grape::API)
+      mounted.namespace :albums do
+        get do
+          declared(params)
+        end
+      end
+
+      subject.format :json
+      subject.namespace :artists do
+        route_param :id, type: Integer do
+          get do
+            declared(params)
+          end
+
+          params do
+            requires :filter, type: String
+          end
+          get :some_route do
+            declared(params)
+          end
+        end
+
+        route_param :artist_id, type: Integer do
+          namespace :compositions do
+            get do
+              declared(params)
+            end
+          end
+        end
+
+        route_param :compositor_id, type: Integer do
+          mount mounted
+        end
+      end
+    end
+
+    it 'return only :id without :artist_id' do
+      get '/artists/1'
+      json = JSON.parse(last_response.body, symbolize_names: true)
+
+      expect(json.key?(:id)).to be_truthy
+      expect(json.key?(:artist_id)).not_to be_truthy
+    end
+
+    it 'return only :artist_id without :id' do
+      get '/artists/1/compositions'
+      json = JSON.parse(last_response.body, symbolize_names: true)
+
+      expect(json.key?(:artist_id)).to be_truthy
+      expect(json.key?(:id)).not_to be_truthy
+    end
+
+    it 'return :filter and :id parameters in declared for second enpoint inside route_param' do
+      get '/artists/1/some_route', filter: 'some_filter'
+      json = JSON.parse(last_response.body, symbolize_names: true)
+
+      expect(json.key?(:filter)).to be_truthy
+      expect(json.key?(:id)).to be_truthy
+      expect(json.key?(:artist_id)).not_to be_truthy
+    end
+
+    it 'return :compositor_id for mounter in route_param' do
+      get '/artists/1/albums'
+      json = JSON.parse(last_response.body, symbolize_names: true)
+
+      expect(json.key?(:compositor_id)).to be_truthy
+      expect(json.key?(:id)).not_to be_truthy
+      expect(json.key?(:artist_id)).not_to be_truthy
+    end
+  end
+end