grape 1.1.0 → 1.5.3

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+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.new(
+          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/validations/validators/values.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 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]
@@ -24,17 +26,23 @@ module Grape
 
       def validate_param!(attr_name, params)
         return unless params.is_a?(Hash)
-        return unless params[attr_name] || required_for_root_scope?
 
-        param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
+        val = params[attr_name]
+
+        return if val.nil? && !required_for_root_scope?
+
+        # don't forget that +false.blank?+ is true
+        return if val != false && val.blank? && @allow_blank
 
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: except_message \
+        param_array = val.nil? ? [nil] : Array.wrap(val)
+
+        raise validation_exception(attr_name, except_message) \
           unless check_excepts(param_array)
 
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:values) \
+        raise validation_exception(attr_name, message(:values)) \
           unless check_values(param_array, attr_name)
 
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:values) \
+        raise validation_exception(attr_name, message(:values)) \
           if @proc && !param_array.all? { |param| @proc.call(param) }
       end
 
@@ -66,6 +74,10 @@ module Grape
       def required_for_root_scope?
         @required && @scope.root?
       end
+
+      def validation_exception(attr_name, message)
+        Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
+      end
     end
   end
 end

data/lib/grape/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module Grape
   # The current version of Grape.
-  VERSION = '1.1.0'.freeze
+  VERSION = '1.5.3'
 end

data/spec/grape/api/custom_validations_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations do
@@ -8,7 +10,7 @@ describe Grape::Validations do
           def validate_param!(attr_name, params)
             @option = params[:max].to_i if params.key?(:max)
             return if params[attr_name].length <= @option
-            raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long"
+            raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long")
           end
         end
       end
@@ -87,7 +89,7 @@ describe Grape::Validations do
       module CustomValidationsSpec
         class WithMessageKey < Grape::Validations::PresenceValidator
           def validate_param!(attr_name, _params)
-            raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: :presence
+            raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: :presence)
           end
         end
       end
@@ -126,7 +128,7 @@ describe Grape::Validations do
             return unless @option
             # check if user is admin or not
             # as an example get a token from request and check if it's admin or not
-            raise Grape::Exceptions::Validation, params: @attrs, message: 'Can not set Admin only field.' unless request.headers['X-Access-Token'] == 'admin'
+            raise Grape::Exceptions::Validation.new(params: @attrs, message: 'Can not set Admin only field.') unless request.headers['X-Access-Token'] == 'admin'
           end
         end
       end

data/spec/grape/api/deeply_included_options_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module DeeplyIncludedOptionsSpec

data/spec/grape/api/defines_boolean_in_params_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+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 type' 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 boolean' do
+        is_expected.to eq 'Grape::API::Boolean'
+      end
+    end
+  end
+end

data/spec/grape/api/inherited_helpers_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::API::Helpers do

data/spec/grape/api/instance_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'shared/versioning_examples'
+
+describe Grape::API::Instance do
+  subject(:an_instance) do
+    Class.new(Grape::API::Instance) do
+      namespace :some_namespace do
+        get 'some_endpoint' do
+          'success'
+        end
+      end
+    end
+  end
+
+  let(:root_api) do
+    to_mount = an_instance
+    Class.new(Grape::API) do
+      mount to_mount
+    end
+  end
+
+  def app
+    root_api
+  end
+
+  context 'when an instance is mounted on the root' do
+    it 'can call the instance endpoint' do
+      get '/some_namespace/some_endpoint'
+      expect(last_response.body).to eq 'success'
+    end
+  end
+
+  context 'when an instance is the root' do
+    let(:root_api) do
+      to_mount = an_instance
+      Class.new(Grape::API::Instance) do
+        mount to_mount
+      end
+    end
+
+    it 'can call the instance endpoint' do
+      get '/some_namespace/some_endpoint'
+      expect(last_response.body).to eq 'success'
+    end
+  end
+
+  context 'top level setting' do
+    it 'does not inherit settings from the superclass (Grape::API::Instance)' do
+      expect(an_instance.top_level_setting.parent).to be_nil
+    end
+  end
+
+  context 'with multiple moutes' do
+    let(:first) do
+      Class.new(Grape::API::Instance) do
+        namespace(:some_namespace) do
+          route :any, '*path' do
+            error!('Not found! (1)', 404)
+          end
+        end
+      end
+    end
+    let(:second) do
+      Class.new(Grape::API::Instance) do
+        namespace(:another_namespace) do
+          route :any, '*path' do
+            error!('Not found! (2)', 404)
+          end
+        end
+      end
+    end
+    let(:root_api) do
+      first_instance = first
+      second_instance = second
+      Class.new(Grape::API) do
+        mount first_instance
+        mount first_instance
+        mount second_instance
+      end
+    end
+
+    it 'does not raise a FrozenError on first instance' do
+      expect { patch '/some_namespace/anything' }.not_to \
+        raise_error
+    end
+
+    it 'responds the correct body at the first instance' do
+      patch '/some_namespace/anything'
+      expect(last_response.body).to eq 'Not found! (1)'
+    end
+
+    it 'does not raise a FrozenError on second instance' do
+      expect { get '/another_namespace/other' }.not_to \
+        raise_error
+    end
+
+    it 'responds the correct body at the second instance' do
+      get '/another_namespace/foobar'
+      expect(last_response.body).to eq 'Not found! (2)'
+    end
+  end
+end

data/spec/grape/api/invalid_format_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Endpoint do

data/spec/grape/api/namespace_parameters_in_route_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Endpoint do

data/spec/grape/api/nested_helpers_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::API::Helpers do

data/spec/grape/api/optional_parameters_in_route_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Endpoint do

data/spec/grape/api/parameters_modification_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Endpoint do
@@ -10,7 +12,7 @@ describe Grape::Endpoint do
   before do
     subject.namespace :test do
       params do
-        optional :foo, default: '-abcdef'
+        optional :foo, default: +'-abcdef'
       end
       get do
         params[:foo].slice!(0)

data/spec/grape/api/patch_method_helpers_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::API::Helpers do

data/spec/grape/api/recognize_path_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::API do

data/spec/grape/api/required_parameters_in_route_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Endpoint do

data/spec/grape/api/required_parameters_with_invalid_method_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Endpoint do

data/spec/grape/api/routes_with_requirements_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+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/shared_helpers_exactly_one_of_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::API::Helpers do

data/spec/grape/api/shared_helpers_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::API::Helpers do

data/spec/grape/api_remount_spec.rb

@@ -0,0 +1,473 @@
+# frozen_string_literal: true
+
+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
+            params do
+              requires configuration[:required_param]
+            end
+            get "/#{configuration[:path]}" do
+              '10 votes'
+            end
+          end
+          root_api.mount a_remounted_api, with: { path: 'votes', required_param: 'param_key' }
+          root_api.mount a_remounted_api, with: { path: 'scores', required_param: 'param_key' }
+        end
+
+        it 'will use the dynamic configuration on all routes' do
+          get 'api/votes', param_key: 'a'
+          expect(last_response.body).to eql '10 votes'
+          get 'api/scores', param_key: 'a'
+          expect(last_response.body).to eql '10 votes'
+          get 'api/votes'
+          expect(last_response.status).to eq 400
+        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