grape 1.1.0 → 1.2.5

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

@@ -158,7 +158,7 @@ module Grape
         #   necessary.
         def enforce_symbolized_keys(type, method)
           # Collections have all values processed individually
-          if type == Array || type == Set
+          if [Array, Set].include?(type)
             lambda do |val|
               method.call(val).tap do |new_value|
                 new_value.map do |item|

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

@@ -19,7 +19,7 @@ module Grape
           # Rack::Request creates a Hash with filename,
           # content type and an IO object. Do a bit of basic
           # duck-typing.
-          value.is_a?(::Hash) && value.key?(:tempfile)
+          value.is_a?(::Hash) && value.key?(:tempfile) && value[:tempfile].is_a?(Tempfile)
         end
       end
     end

data/lib/grape/validations/validator_factory.rb

@@ -1,17 +1,12 @@
 module Grape
   module Validations
     class ValidatorFactory
-      def initialize(**options)
-        @validator_class = options.delete(:validator_class)
-        @options         = options
-      end
-
-      def create_validator
-        @validator_class.new(@options[:attributes],
-                             @options[:options],
-                             @options[:required],
-                             @options[:params_scope],
-                             @options[:opts])
+      def self.create_validator(**options)
+        options[:validator_class].new(options[:attributes],
+                                      options[:options],
+                                      options[:required],
+                                      options[:params_scope],
+                                      options[:opts])
       end
     end
   end

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

@@ -1,19 +1,12 @@
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/multiple_params_base'
     class AllOrNoneOfValidator < MultipleParamsBase
-      def validate!(params)
-        super
-        if scope_requires_params && only_subset_present
-          raise Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none)
-        end
-        params
-      end
-
-      private
-
-      def only_subset_present
-        scoped_params.any? { |resource_params| !keys_in_common(resource_params).empty? && keys_in_common(resource_params).length < attrs.length }
+      def validate_params!(params)
+        keys = keys_in_common(params)
+        return if keys.empty? || keys.length == all_keys.length
+        raise Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none)
       end
     end
   end

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

@@ -2,13 +2,12 @@ module Grape
   module Validations
     class AsValidator < Base
       def initialize(attrs, options, required, scope, opts = {})
-        @alias = options
+        @renamed_options = options
         super
       end
 
       def validate_param!(attr_name, params)
-        params[@alias] = params[attr_name]
-        params.delete(attr_name)
+        params[@renamed_options] = params[attr_name]
       end
     end
   end

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

@@ -1,19 +1,11 @@
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/multiple_params_base'
     class AtLeastOneOfValidator < MultipleParamsBase
-      def validate!(params)
-        super
-        if scope_requires_params && no_exclusive_params_are_present
-          raise Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
-        end
-        params
-      end
-
-      private
-
-      def no_exclusive_params_are_present
-        scoped_params.any? { |resource_params| keys_in_common(resource_params).empty? }
+      def validate_params!(params)
+        return unless keys_in_common(params).empty?
+        raise Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
       end
     end
   end

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

@@ -35,18 +35,19 @@ module Grape
       # @raise [Grape::Exceptions::Validation] if validation failed
       # @return [void]
       def validate!(params)
-        attributes = AttributesIterator.new(self, @scope, params)
+        attributes = SingleAttributeIterator.new(self, @scope, params)
+        # we collect errors inside array because
+        # there may be more than one error per field
         array_errors = []
+
         attributes.each do |resource_params, attr_name|
           next if !@scope.required? && resource_params.empty?
-          next unless @required || (resource_params.respond_to?(:key?) && resource_params.key?(attr_name))
           next unless @scope.meets_dependency?(resource_params, params)
-
           begin
-            validate_param!(attr_name, resource_params)
+            if @required || resource_params.respond_to?(:key?) && resource_params.key?(attr_name)
+              validate_param!(attr_name, resource_params)
+            end
           rescue Grape::Exceptions::Validation => e
-            # we collect errors inside array because
-            # there may be more than one error per field
             array_errors << e
           end
         end
@@ -56,10 +57,10 @@ module Grape
 
       def self.convert_to_short_name(klass)
         ret = klass.name.gsub(/::/, '/')
-                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                   .tr('-', '_')
-                   .downcase
+        ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        ret.tr!('-', '_')
+        ret.downcase!
         File.basename(ret, '_validator')
       end
 

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

@@ -1,6 +1,10 @@
 module Grape
   class API
     Boolean = Virtus::Attribute::Boolean
+
+    class Instance
+      Boolean = Virtus::Attribute::Boolean
+    end
   end
 
   module Validations

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

@@ -18,7 +18,7 @@ module Grape
       end
 
       def validate!(params)
-        attrs = AttributesIterator.new(self, @scope, 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)

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

@@ -1,28 +1,11 @@
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/mutual_exclusion'
-    class ExactlyOneOfValidator < MutualExclusionValidator
-      def validate!(params)
-        super
-        if scope_requires_params && none_of_restricted_params_is_present
-          raise Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one)
-        end
-        params
-      end
-
-      def message(default_key = nil)
-        options = instance_variable_get(:@option)
-        if options_key?(:message)
-          (options_key?(default_key, options[:message]) ? options[:message][default_key] : options[:message])
-        else
-          default_key
-        end
-      end
-
-      private
-
-      def none_of_restricted_params_is_present
-        scoped_params.any? { |resource_params| keys_in_common(resource_params).empty? }
+    class ExactlyOneOfValidator < MultipleParamsBase
+      def validate_params!(params)
+        return if keys_in_common(params).length == 1
+        raise Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one)
       end
     end
   end

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

@@ -1,26 +1,30 @@
 module Grape
   module Validations
     class MultipleParamsBase < Base
-      attr_reader :scoped_params
-
       def validate!(params)
-        @scoped_params = [@scope.params(params)].flatten
-        params
-      end
+        attributes = MultipleAttributesIterator.new(self, @scope, params)
+        array_errors = []
 
-      private
+        attributes.each do |resource_params|
+          begin
+            validate_params!(resource_params)
+          rescue Grape::Exceptions::Validation => e
+            array_errors << e
+          end
+        end
 
-      def scope_requires_params
-        @scope.required? || scoped_params.any?(&:any?)
+        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
       end
 
+      private
+
       def keys_in_common(resource_params)
         return [] unless resource_params.is_a?(Hash)
-        (all_keys & resource_params.stringify_keys.keys).map(&:to_s)
+        all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
       end
 
       def all_keys
-        attrs.map(&:to_s)
+        attrs.map { |attr| @scope.full_name(attr) }
       end
     end
   end

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

@@ -1,24 +1,12 @@
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/multiple_params_base'
     class MutualExclusionValidator < MultipleParamsBase
-      attr_reader :processing_keys_in_common
-
-      def validate!(params)
-        super
-        if two_or_more_exclusive_params_are_present
-          raise Grape::Exceptions::Validation, params: processing_keys_in_common, message: message(:mutual_exclusion)
-        end
-        params
-      end
-
-      private
-
-      def two_or_more_exclusive_params_are_present
-        scoped_params.any? do |resource_params|
-          @processing_keys_in_common = keys_in_common(resource_params)
-          @processing_keys_in_common.length > 1
-        end
+      def validate_params!(params)
+        keys = keys_in_common(params)
+        return if keys.length <= 1
+        raise Grape::Exceptions::Validation, params: keys, message: message(:mutual_exclusion)
       end
     end
   end

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

@@ -0,0 +1,23 @@
+module Grape
+  module Validations
+    class SameAsValidator < Base
+      def validate_param!(attr_name, params)
+        confirmation = options_key?(:value) ? @option[:value] : @option
+        return if params[attr_name] == params[confirmation]
+        raise Grape::Exceptions::Validation,
+              params: [@scope.full_name(attr_name)],
+              message: build_message
+      end
+
+      private
+
+      def build_message
+        if options_key?(:message)
+          @option[:message]
+        else
+          format I18n.t(:same_as, scope: 'grape.errors.messages'), parameter: @option
+        end
+      end
+    end
+  end
+end

data/lib/grape/version.rb

@@ -1,4 +1,4 @@
 module Grape
   # The current version of Grape.
-  VERSION = '1.1.0'.freeze
+  VERSION = '1.2.5'.freeze
 end

data/spec/grape/api/defines_boolean_in_params_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Grape::API::Instance do
+  describe 'boolean constant' do
+    module DefinesBooleanInstanceSpec
+      class API < Grape::API
+        params do
+          requires :message, type: Boolean
+        end
+        post :echo do
+          { class: params[:message].class.name, value: params[:message] }
+        end
+      end
+    end
+
+    def app
+      DefinesBooleanInstanceSpec::API
+    end
+
+    let(:expected_body) do
+      { class: 'TrueClass', value: true }.to_s
+    end
+
+    it 'sets Boolean as a Virtus::Attribute::Boolean' do
+      post '/echo?message=true'
+      expect(last_response.status).to eq(201)
+      expect(last_response.body).to eq expected_body
+    end
+
+    context 'Params endpoint type' do
+      subject { DefinesBooleanInstanceSpec::API.new.router.map['POST'].first.options[:params]['message'][:type] }
+      it 'params type is a Virtus::Attribute::Boolean' do
+        is_expected.to eq 'Virtus::Attribute::Boolean'
+      end
+    end
+  end
+end

data/spec/grape/api/routes_with_requirements_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Grape::Endpoint do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  context 'get' do
+    it 'routes to a namespace param with dots' do
+      subject.namespace ':ns_with_dots', requirements: { ns_with_dots: %r{[^\/]+} } do
+        get '/' do
+          params[:ns_with_dots]
+        end
+      end
+
+      get '/test.id.with.dots'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'test.id.with.dots'
+    end
+
+    it 'routes to a path with multiple params with dots' do
+      subject.get ':id_with_dots/:another_id_with_dots', requirements: { id_with_dots: %r{[^\/]+},
+                                                                         another_id_with_dots: %r{[^\/]+} } do
+        "#{params[:id_with_dots]}/#{params[:another_id_with_dots]}"
+      end
+
+      get '/test.id/test2.id'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'test.id/test2.id'
+    end
+
+    it 'routes to namespace and path params with dots, with overridden requirements' do
+      subject.namespace ':ns_with_dots', requirements: { ns_with_dots: %r{[^\/]+} } do
+        get ':another_id_with_dots',     requirements: { ns_with_dots: %r{[^\/]+},
+                                                         another_id_with_dots: %r{[^\/]+} } do
+          "#{params[:ns_with_dots]}/#{params[:another_id_with_dots]}"
+        end
+      end
+
+      get '/test.id/test2.id'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'test.id/test2.id'
+    end
+
+    it 'routes to namespace and path params with dots, with merged requirements' do
+      subject.namespace ':ns_with_dots', requirements: { ns_with_dots: %r{[^\/]+} } do
+        get ':another_id_with_dots',     requirements: { another_id_with_dots: %r{[^\/]+} } do
+          "#{params[:ns_with_dots]}/#{params[:another_id_with_dots]}"
+        end
+      end
+
+      get '/test.id/test2.id'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'test.id/test2.id'
+    end
+  end
+end

data/spec/grape/api_remount_spec.rb

@@ -0,0 +1,466 @@
+require 'spec_helper'
+require 'shared/versioning_examples'
+
+describe Grape::API do
+  subject(:a_remounted_api) { Class.new(Grape::API) }
+  let(:root_api) { Class.new(Grape::API) }
+
+  def app
+    root_api
+  end
+
+  describe 'remounting an API' do
+    context 'with a defined route' do
+      before do
+        a_remounted_api.get '/votes' do
+          '10 votes'
+        end
+      end
+
+      context 'when mounting one instance' do
+        before do
+          root_api.mount a_remounted_api
+        end
+
+        it 'can access the endpoint' do
+          get '/votes'
+          expect(last_response.body).to eql '10 votes'
+        end
+      end
+
+      context 'when mounting twice' do
+        before do
+          root_api.mount a_remounted_api => '/posts'
+          root_api.mount a_remounted_api => '/comments'
+        end
+
+        it 'can access the votes in both places' do
+          get '/posts/votes'
+          expect(last_response.body).to eql '10 votes'
+          get '/comments/votes'
+          expect(last_response.body).to eql '10 votes'
+        end
+      end
+
+      context 'when mounting on namespace' do
+        before do
+          stub_const('StaticRefToAPI', a_remounted_api)
+          root_api.namespace 'posts' do
+            mount StaticRefToAPI
+          end
+
+          root_api.namespace 'comments' do
+            mount StaticRefToAPI
+          end
+        end
+
+        it 'can access the votes in both places' do
+          get '/posts/votes'
+          expect(last_response.body).to eql '10 votes'
+          get '/comments/votes'
+          expect(last_response.body).to eql '10 votes'
+        end
+      end
+    end
+
+    describe 'with dynamic configuration' do
+      context 'when mounting an endpoint conditional on a configuration' do
+        subject(:a_remounted_api) do
+          Class.new(Grape::API) do
+            get 'always' do
+              'success'
+            end
+
+            given configuration[:mount_sometimes] do
+              get 'sometimes' do
+                'sometimes'
+              end
+            end
+          end
+        end
+
+        it 'mounts the endpoints only when configured to do so' do
+          root_api.mount({ a_remounted_api => 'with_conditional' }, with: { mount_sometimes: true })
+          root_api.mount({ a_remounted_api => 'without_conditional' }, with: { mount_sometimes: false })
+
+          get '/with_conditional/always'
+          expect(last_response.body).to eq 'success'
+
+          get '/with_conditional/sometimes'
+          expect(last_response.body).to eq 'sometimes'
+
+          get '/without_conditional/always'
+          expect(last_response.body).to eq 'success'
+
+          get '/without_conditional/sometimes'
+          expect(last_response.status).to eq 404
+        end
+      end
+
+      context 'when using an expression derived from a configuration' do
+        subject(:a_remounted_api) do
+          Class.new(Grape::API) do
+            get(mounted { "api_name_#{configuration[:api_name]}" }) do
+              'success'
+            end
+          end
+        end
+
+        before do
+          root_api.mount a_remounted_api, with: {
+            api_name: 'a_name'
+          }
+        end
+
+        it 'mounts the endpoint with the name' do
+          get 'api_name_a_name'
+          expect(last_response.body).to eq 'success'
+        end
+
+        it 'does not mount the endpoint with a null name' do
+          get 'api_name_'
+          expect(last_response.body).not_to eq 'success'
+        end
+
+        context 'when the expression lives in a namespace' do
+          subject(:a_remounted_api) do
+            Class.new(Grape::API) do
+              namespace :base do
+                get(mounted { "api_name_#{configuration[:api_name]}" }) do
+                  'success'
+                end
+              end
+            end
+          end
+
+          it 'mounts the endpoint with the name' do
+            get 'base/api_name_a_name'
+            expect(last_response.body).to eq 'success'
+          end
+
+          it 'does not mount the endpoint with a null name' do
+            get 'base/api_name_'
+            expect(last_response.body).not_to eq 'success'
+          end
+        end
+      end
+
+      context 'when executing a standard block within a `mounted` block with all dynamic params' do
+        subject(:a_remounted_api) do
+          Class.new(Grape::API) do
+            mounted do
+              desc configuration[:description] do
+                headers configuration[:headers]
+              end
+              get configuration[:endpoint] do
+                configuration[:response]
+              end
+            end
+          end
+        end
+
+        let(:api_endpoint) { 'custom_endpoint' }
+        let(:api_response) { 'custom response' }
+        let(:endpoint_description) { 'this is a custom API' }
+        let(:headers) do
+          {
+            'XAuthToken' => {
+              'description' => 'Validates your identity',
+              'required' => true
+            }
+          }
+        end
+
+        it 'mounts the API and obtains the description and headers definition' do
+          root_api.mount a_remounted_api, with: {
+            description: endpoint_description,
+            headers: headers,
+            endpoint: api_endpoint,
+            response: api_response
+          }
+          get api_endpoint
+          expect(last_response.body).to eq api_response
+          expect(a_remounted_api.instances.last.endpoints.first.options[:route_options][:description])
+            .to eq endpoint_description
+          expect(a_remounted_api.instances.last.endpoints.first.options[:route_options][:headers])
+            .to eq headers
+        end
+      end
+
+      context 'when executing a custom block on mount' do
+        subject(:a_remounted_api) do
+          Class.new(Grape::API) do
+            get 'always' do
+              'success'
+            end
+
+            mounted do
+              configuration[:endpoints].each do |endpoint_name, endpoint_response|
+                get endpoint_name do
+                  endpoint_response
+                end
+              end
+            end
+          end
+        end
+
+        it 'mounts the endpoints only when configured to do so' do
+          root_api.mount a_remounted_api, with: { endpoints: { 'api_name' => 'api_response' } }
+          get 'api_name'
+          expect(last_response.body).to eq 'api_response'
+        end
+      end
+
+      context 'when the configuration is part of the arguments of a method' do
+        subject(:a_remounted_api) do
+          Class.new(Grape::API) do
+            get configuration[:endpoint_name] do
+              'success'
+            end
+          end
+        end
+
+        it 'mounts the endpoint in the location it is configured' do
+          root_api.mount a_remounted_api, with: { endpoint_name: 'some_location' }
+          get '/some_location'
+          expect(last_response.body).to eq 'success'
+
+          get '/different_location'
+          expect(last_response.status).to eq 404
+
+          root_api.mount a_remounted_api, with: { endpoint_name: 'new_location' }
+          get '/new_location'
+          expect(last_response.body).to eq 'success'
+        end
+
+        context 'when the configuration is the value in a key-arg pair' do
+          subject(:a_remounted_api) do
+            Class.new(Grape::API) do
+              version 'v1', using: :param, parameter: configuration[:version_param]
+              get 'endpoint' do
+                'version 1'
+              end
+
+              version 'v2', using: :param, parameter: configuration[:version_param]
+              get 'endpoint' do
+                'version 2'
+              end
+            end
+          end
+
+          it 'takes the param from the configuration' do
+            root_api.mount a_remounted_api, with: { version_param: 'param_name' }
+
+            get '/endpoint?param_name=v1'
+            expect(last_response.body).to eq 'version 1'
+
+            get '/endpoint?param_name=v2'
+            expect(last_response.body).to eq 'version 2'
+
+            get '/endpoint?wrong_param_name=v2'
+            expect(last_response.body).to eq 'version 1'
+          end
+        end
+      end
+
+      context 'on the DescSCope' do
+        subject(:a_remounted_api) do
+          Class.new(Grape::API) do
+            desc 'The description of this' do
+              tags ['not_configurable_tag', configuration[:a_configurable_tag]]
+            end
+            get 'location' do
+              'success'
+            end
+          end
+        end
+
+        it 'mounts the endpoint with the appropiate tags' do
+          root_api.mount({ a_remounted_api => 'integer' }, with: { a_configurable_tag: 'a configured tag' })
+        end
+      end
+
+      context 'on the ParamScope' do
+        subject(:a_remounted_api) do
+          Class.new(Grape::API) do
+            params do
+              requires configuration[:required_param], type: configuration[:required_type]
+            end
+
+            get 'location' do
+              'success'
+            end
+          end
+        end
+
+        it 'mounts the endpoint in the location it is configured' do
+          root_api.mount({ a_remounted_api => 'string' }, with: { required_param: 'param_key', required_type: String })
+          root_api.mount({ a_remounted_api => 'integer' }, with: { required_param: 'param_integer', required_type: Integer })
+
+          get '/string/location', param_key: 'a'
+          expect(last_response.body).to eq 'success'
+
+          get '/string/location', param_integer: 1
+          expect(last_response.status).to eq 400
+
+          get '/integer/location', param_integer: 1
+          expect(last_response.body).to eq 'success'
+
+          get '/integer/location', param_integer: 'a'
+          expect(last_response.status).to eq 400
+        end
+
+        context 'on dynamic checks' do
+          subject(:a_remounted_api) do
+            Class.new(Grape::API) do
+              params do
+                optional :restricted_values, values: -> { [configuration[:allowed_value], 'always'] }
+              end
+
+              get 'location' do
+                'success'
+              end
+            end
+          end
+
+          it 'can read the configuration on lambdas' do
+            root_api.mount a_remounted_api, with: { allowed_value: 'sometimes' }
+            get '/location', restricted_values: 'always'
+            expect(last_response.body).to eq 'success'
+            get '/location', restricted_values: 'sometimes'
+            expect(last_response.body).to eq 'success'
+            get '/location', restricted_values: 'never'
+            expect(last_response.status).to eq 400
+          end
+        end
+      end
+
+      context 'when the configuration is read within a namespace' do
+        before do
+          a_remounted_api.namespace 'api' do
+            get "/#{configuration[:path]}" do
+              '10 votes'
+            end
+          end
+          root_api.mount a_remounted_api, with: { path: 'votes' }
+          root_api.mount a_remounted_api, with: { path: 'scores' }
+        end
+
+        it 'will use the dynamic configuration on all routes' do
+          get 'api/votes'
+          expect(last_response.body).to eql '10 votes'
+          get 'api/scores'
+          expect(last_response.body).to eql '10 votes'
+        end
+      end
+
+      context 'a very complex configuration example' do
+        before do
+          top_level_api = Class.new(Grape::API) do
+            remounted_api = Class.new(Grape::API) do
+              get configuration[:endpoint_name] do
+                configuration[:response]
+              end
+            end
+
+            expression_namespace = mounted { configuration[:namespace].to_s * 2 }
+            given(mounted { configuration[:should_mount_expressed] != false }) do
+              namespace expression_namespace do
+                mount remounted_api, with: { endpoint_name: configuration[:endpoint_name], response: configuration[:endpoint_response] }
+              end
+            end
+          end
+          root_api.mount top_level_api, with: configuration_options
+        end
+
+        context 'when the namespace should be mounted' do
+          let(:configuration_options) do
+            {
+              should_mount_expressed: true,
+              namespace: 'bang',
+              endpoint_name: 'james',
+              endpoint_response: 'bond'
+            }
+          end
+
+          it 'gets a response' do
+            get 'bangbang/james'
+            expect(last_response.body).to eq 'bond'
+          end
+        end
+
+        context 'when should be mounted is nil' do
+          let(:configuration_options) do
+            {
+              should_mount_expressed: nil,
+              namespace: 'bang',
+              endpoint_name: 'james',
+              endpoint_response: 'bond'
+            }
+          end
+
+          it 'gets a response' do
+            get 'bangbang/james'
+            expect(last_response.body).to eq 'bond'
+          end
+        end
+
+        context 'when it should not be mounted' do
+          let(:configuration_options) do
+            {
+              should_mount_expressed: false,
+              namespace: 'bang',
+              endpoint_name: 'james',
+              endpoint_response: 'bond'
+            }
+          end
+
+          it 'gets a response' do
+            get 'bangbang/james'
+            expect(last_response.body).not_to eq 'bond'
+          end
+        end
+      end
+
+      context 'when the configuration is read in a helper' do
+        subject(:a_remounted_api) do
+          Class.new(Grape::API) do
+            helpers do
+              def printed_response
+                configuration[:some_value]
+              end
+            end
+
+            get 'location' do
+              printed_response
+            end
+          end
+        end
+
+        it 'will use the dynamic configuration on all routes' do
+          root_api.mount(a_remounted_api, with: { some_value: 'response value' })
+
+          get '/location'
+          expect(last_response.body).to eq 'response value'
+        end
+      end
+
+      context 'when the configuration is read within the response block' do
+        subject(:a_remounted_api) do
+          Class.new(Grape::API) do
+            get 'location' do
+              configuration[:some_value]
+            end
+          end
+        end
+
+        it 'will use the dynamic configuration on all routes' do
+          root_api.mount(a_remounted_api, with: { some_value: 'response value' })
+
+          get '/location'
+          expect(last_response.body).to eq 'response value'
+        end
+      end
+    end
+  end
+end