grape 1.2.4 → 1.2.5

data/lib/grape/version.rb

@@ -1,4 +1,4 @@
 module Grape
   # The current version of Grape.
-  VERSION = '1.2.4'.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_remount_spec.rb

@@ -97,6 +97,96 @@ describe Grape::API do
         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
@@ -264,6 +354,74 @@ describe Grape::API do
         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

data/spec/grape/api_spec.rb

@@ -885,6 +885,40 @@ XML
     end
   end
 
+  describe '.compile!' do
+    it 'requires the grape/eager_load file' do
+      expect(app).to receive(:require).with('grape/eager_load') { nil }
+      app.compile!
+    end
+
+    it 'compiles the instance for rack!' do
+      stubbed_object = double(:instance_for_rack)
+      allow(app).to receive(:instance_for_rack) { stubbed_object }
+    end
+  end
+
+  # NOTE: this method is required to preserve the ability of pre-mounting
+  # the root API into a namespace, it may be deprecated in the future.
+  describe 'instance_for_rack' do
+    context 'when the app was not mounted' do
+      it 'returns the base_instance' do
+        expect(app.send(:instance_for_rack)).to eq app.base_instance
+      end
+    end
+
+    context 'when the app was mounted' do
+      it 'returns the first mounted instance' do
+        mounted_app = app
+        Class.new(Grape::API) do
+          namespace 'new_namespace' do
+            mount mounted_app
+          end
+        end
+        expect(app.send(:instance_for_rack)).to eq app.send(:mounted_instances).first
+      end
+    end
+  end
+
   describe 'filters' do
     it 'adds a before filter' do
       subject.before { @foo = 'first'  }
@@ -3720,6 +3754,44 @@ XML
     end
   end
 
+  describe '.configure' do
+    context 'when given a block' do
+      it 'returns self' do
+        expect(subject.configure {}).to be subject
+      end
+
+      it 'calls the block passing the config' do
+        call = [false, nil]
+        subject.configure do |config|
+          call = [true, config]
+        end
+
+        expect(call[0]).to be true
+        expect(call[1]).not_to be_nil
+      end
+    end
+
+    context 'when not given a block' do
+      it 'returns a configuration object' do
+        expect(subject.configure).to respond_to(:[], :[]=)
+      end
+    end
+
+    it 'allows configuring the api' do
+      subject.configure do |config|
+        config[:hello] = 'hello'
+        config[:bread] = 'bread'
+      end
+
+      subject.get '/hello-bread' do
+        "#{configuration[:hello]} #{configuration[:bread]}"
+      end
+
+      get '/hello-bread'
+      expect(last_response.body).to eq 'hello bread'
+    end
+  end
+
   context 'catch-all' do
     before do
       api1 = Class.new(Grape::API)

data/spec/grape/endpoint_spec.rb

@@ -8,7 +8,7 @@ describe Grape::Endpoint do
   end
 
   describe '.before_each' do
-    after { Grape::Endpoint.before_each(nil) }
+    after { Grape::Endpoint.before_each.clear }
 
     it 'is settable via block' do
       block = ->(_endpoint) { 'noop' }

data/spec/grape/exceptions/base_spec.rb

@@ -8,8 +8,11 @@ describe Grape::Exceptions::Base do
     let(:attributes) { { klass: String, to_format: 'xml' } }
 
     after do
+      I18n.enforce_available_locales = true
       I18n.available_locales = %i[en]
+      I18n.locale = :en
       I18n.default_locale = :en
+      I18n.reload!
     end
 
     context 'when I18n enforces available locales' do
@@ -29,6 +32,7 @@ describe Grape::Exceptions::Base do
       context 'when the fallback locale is not available' do
         before do
           I18n.available_locales = %i[de jp]
+          I18n.locale = :de
           I18n.default_locale = :de
         end
 

data/spec/grape/exceptions/validation_errors_spec.rb

@@ -77,10 +77,12 @@ describe Grape::Exceptions::ValidationErrors do
       end
       get '/exactly_one_of', beer: 'string', wine: 'anotherstring'
       expect(last_response.status).to eq(400)
-      expect(JSON.parse(last_response.body)).to eq([
-                                                     'params' => %w[beer wine],
-                                                     'messages' => ['are mutually exclusive']
-                                                   ])
+      expect(JSON.parse(last_response.body)).to eq(
+        [
+          'params' => %w[beer wine juice],
+          'messages' => ['are missing, exactly one parameter must be provided']
+        ]
+      )
     end
   end
 end

data/spec/grape/integration/rack_spec.rb

@@ -19,16 +19,32 @@ describe Rack do
       }
       env = Rack::MockRequest.env_for('/', options)
 
-      unless RUBY_PLATFORM == 'java'
-        major, minor, patch = Rack.release.split('.').map(&:to_i)
-        patch ||= 0 # rack <= 1.5.2 does not specify patch version
-        pending 'Rack 1.5.3 or 1.6.1 required' unless major >= 2 || (major >= 1 && ((minor == 5 && patch >= 3) || (minor >= 6)))
-      end
-
       expect(JSON.parse(app.call(env)[2].body.first)['params_keys']).to match_array('test')
     ensure
       input.close
       input.unlink
     end
   end
+
+  context 'when the app is mounted' do
+    def app
+      @main_app ||= Class.new(Grape::API) do
+        get 'ping'
+      end
+    end
+
+    let!(:base) do
+      app_to_mount = app
+      Class.new(Grape::API) do
+        namespace 'namespace' do
+          mount app_to_mount
+        end
+      end
+    end
+
+    it 'finds the app on the namespace' do
+      get '/namespace/ping'
+      expect(last_response.status).to eq 200
+    end
+  end
 end

data/spec/grape/middleware/base_spec.rb

@@ -114,6 +114,14 @@ describe Grape::Middleware::Base do
     end
   end
 
+  describe '#context' do
+    subject { Grape::Middleware::Base.new(blank_app) }
+    it 'allows access to response context' do
+      subject.call(Grape::Env::API_ENDPOINT => { header: 'some header' })
+      expect(subject.context).to eq(header: 'some header')
+    end
+  end
+
   context 'options' do
     it 'persists options passed at initialization' do
       expect(Grape::Middleware::Base.new(blank_app, abc: true).options[:abc]).to be true

data/spec/grape/middleware/formatter_spec.rb

@@ -213,7 +213,13 @@ describe Grape::Middleware::Formatter do
   context 'no content responses' do
     let(:no_content_response) { ->(status) { [status, {}, ['']] } }
 
-    Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.each do |status|
+    STATUSES_WITHOUT_BODY = if Gem::Version.new(Rack.release) >= Gem::Version.new('2.1.0')
+                              Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.keys
+                            else
+                              Rack::Utils::STATUS_WITH_NO_ENTITY_BODY
+                            end
+
+    STATUSES_WITHOUT_BODY.each do |status|
       it "does not modify a #{status} response" do
         expected_response = no_content_response[status]
         allow(app).to receive(:call).and_return(expected_response)
@@ -391,6 +397,10 @@ describe Grape::Middleware::Formatter do
       Grape::Formatter.register :invalid, InvalidFormatter
       Grape::ContentTypes::CONTENT_TYPES[:invalid] = 'application/x-invalid'
     end
+    after do
+      Grape::ContentTypes::CONTENT_TYPES.delete(:invalid)
+      Grape::Formatter.default_elements.delete(:invalid)
+    end
 
     it 'returns response by invalid formatter' do
       env = { 'PATH_INFO' => '/hello.invalid', 'HTTP_ACCEPT' => 'application/x-invalid' }

data/spec/grape/validations/multiple_attributes_iterator_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Grape::Validations::MultipleAttributesIterator do
+  describe '#each' do
+    subject(:iterator) { described_class.new(validator, scope, params) }
+    let(:scope) { Grape::Validations::ParamsScope.new(api: Class.new(Grape::API)) }
+    let(:validator) { double(attrs: %i[first second third]) }
+
+    context 'when params is a hash' do
+      let(:params) do
+        { first: 'string', second: 'string' }
+      end
+
+      it 'yields the whole params hash without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_with_args(params)
+      end
+    end
+
+    context 'when params is an array' do
+      let(:params) do
+        [{ first: 'string1', second: 'string1' }, { first: 'string2', second: 'string2' }]
+      end
+
+      it 'yields each element of the array without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_successive_args(params[0], params[1])
+      end
+    end
+  end
+end