grape 1.1.0 → 1.2.5

data/spec/grape/dsl/desc_spec.rb

@@ -21,36 +21,60 @@ module Grape
 
         it 'can be set with a block' do
           expected_options = {
+            summary: 'summary',
             description: 'The description',
             detail: 'more details',
             params: { first: :param },
             entity: Object,
             http_codes: [[401, 'Unauthorized', 'Entities::Error']],
             named: 'My named route',
-            headers: [XAuthToken: {
-              description: 'Valdates your identity',
-              required: true
-            },
-                      XOptionalHeader: {
-                        description: 'Not really needed',
-                        required: false
-                      }]
+            body_name: 'My body name',
+            headers: [
+              XAuthToken: {
+                description: 'Valdates your identity',
+                required: true
+              },
+              XOptionalHeader: {
+                description: 'Not really needed',
+                required: false
+              }
+            ],
+            hidden: false,
+            deprecated: false,
+            is_array: true,
+            nickname: 'nickname',
+            produces: %w[array of mime_types],
+            consumes: %w[array of mime_types],
+            tags: %w[tag1 tag2],
+            security: %w[array of security schemes]
           }
 
           subject.desc 'The description' do
+            summary 'summary'
             detail 'more details'
             params(first: :param)
             success Object
             failure [[401, 'Unauthorized', 'Entities::Error']]
             named 'My named route'
-            headers [XAuthToken: {
-              description: 'Valdates your identity',
-              required: true
-            },
-                     XOptionalHeader: {
-                       description: 'Not really needed',
-                       required: false
-                     }]
+            body_name 'My body name'
+            headers [
+              XAuthToken: {
+                description: 'Valdates your identity',
+                required: true
+              },
+              XOptionalHeader: {
+                description: 'Not really needed',
+                required: false
+              }
+            ]
+            hidden false
+            deprecated false
+            is_array true
+            nickname 'nickname'
+            produces %w[array of mime_types]
+            consumes %w[array of mime_types]
+            tags %w[tag1 tag2]
+            security %w[array of security schemes]
           end
 
           expect(subject.namespace_setting(:description)).to eq(expected_options)

data/spec/grape/dsl/middleware_spec.rb

@@ -22,6 +22,14 @@ module Grape
         end
       end
 
+      describe '.insert' do
+        it 'adds a middleware with the right operation' do
+          expect(subject).to receive(:namespace_stackable).with(:middleware, [:insert, 0, :arg1, proc])
+
+          subject.insert 0, :arg1, &proc
+        end
+      end
+
       describe '.insert_before' do
         it 'adds a middleware with the right operation' do
           expect(subject).to receive(:namespace_stackable).with(:middleware, [:insert_before, foo_middleware, :arg1, proc])

data/spec/grape/dsl/routing_spec.rb

@@ -70,6 +70,16 @@ module Grape
 
           expect(app2.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app1', '/app2'])
         end
+
+        it 'mounts multiple routes at once' do
+          base_app = Class.new(Grape::API)
+          app1     = Class.new(Grape::API)
+          app2     = Class.new(Grape::API)
+          base_app.mount(app1 => '/app1', app2 => '/app2')
+
+          expect(app1.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app1'])
+          expect(app2.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app2'])
+        end
       end
 
       describe '.route' do

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' }
@@ -472,12 +472,12 @@ describe Grape::Endpoint do
       expect(last_response.status).to eq(200)
     end
 
-    it 'does not include aliased missing attributes if that option is passed' do
+    it 'does not include renamed missing attributes if that option is passed' do
       subject.params do
-        optional :aliased_original, as: :aliased
+        optional :renamed_original, as: :renamed
       end
       subject.get '/declared' do
-        error! 'expected nil', 400 if declared(params, include_missing: false).key?(:aliased)
+        error! 'expected nil', 400 if declared(params, include_missing: false).key?(:renamed)
         ''
       end
 
@@ -1089,6 +1089,36 @@ describe Grape::Endpoint do
       expect(last_response.headers['X-Custom']).to eq('value')
     end
 
+    it 'merges additional headers with headers set before call' do
+      subject.before do
+        header 'X-Before-Test', 'before-sample'
+      end
+
+      subject.get '/hey' do
+        header 'X-Test', 'test-sample'
+        error!({ 'dude' => 'rad' }, 403, 'X-Error' => 'error')
+      end
+
+      get '/hey.json'
+      expect(last_response.headers['X-Before-Test']).to eq('before-sample')
+      expect(last_response.headers['X-Test']).to eq('test-sample')
+      expect(last_response.headers['X-Error']).to eq('error')
+    end
+
+    it 'does not merges additional headers with headers set after call' do
+      subject.after do
+        header 'X-After-Test', 'after-sample'
+      end
+
+      subject.get '/hey' do
+        error!({ 'dude' => 'rad' }, 403, 'X-Error' => 'error')
+      end
+
+      get '/hey.json'
+      expect(last_response.headers['X-Error']).to eq('error')
+      expect(last_response.headers['X-After-Test']).to be_nil
+    end
+
     it 'sets the status code for the endpoint' do
       memoized_endpoint = nil
 
@@ -1492,6 +1522,9 @@ describe Grape::Endpoint do
         have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
+                                                                       filters: [],
+                                                                       type: :finally }),
         have_attributes(name: 'endpoint_run.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                env: an_instance_of(Hash) }),
         have_attributes(name: 'format_response.grape', payload: { env: an_instance_of(Hash),
@@ -1518,6 +1551,9 @@ describe Grape::Endpoint do
         have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
+                                                                       filters: [],
+                                                                       type: :finally }),
         have_attributes(name: 'format_response.grape', payload: { env: an_instance_of(Hash),
                                                                   formatter: a_kind_of(Module) })
       )

data/spec/grape/exceptions/base_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Grape::Exceptions::Base do
+  describe '#compose_message' do
+    subject { described_class.new.send(:compose_message, key, attributes) }
+
+    let(:key) { :invalid_formatter }
+    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
+      before { I18n.enforce_available_locales = true }
+
+      context 'when the fallback locale is available' do
+        before do
+          I18n.available_locales = %i[de en]
+          I18n.default_locale = :de
+        end
+
+        it 'returns the translated message' do
+          expect(subject).to eq('cannot convert String to xml')
+        end
+      end
+
+      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
+
+        it 'returns the translation string' do
+          expect(subject).to eq("grape.errors.messages.#{key}")
+        end
+      end
+    end
+
+    context 'when I18n does not enforce available locales' do
+      before { I18n.enforce_available_locales = false }
+
+      context 'when the fallback locale is available' do
+        before { I18n.available_locales = %i[de en] }
+
+        it 'returns the translated message' do
+          expect(subject).to eq('cannot convert String to xml')
+        end
+      end
+
+      context 'when the fallback locale is not available' do
+        before { I18n.available_locales = %i[de jp] }
+
+        it 'returns the translated message' do
+          expect(subject).to eq('cannot convert String to xml')
+        end
+      end
+    end
+  end
+end

data/spec/grape/exceptions/invalid_response_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Grape::Exceptions::InvalidResponse do
+  describe '#message' do
+    let(:error) { described_class.new }
+
+    it 'contains the problem in the message' do
+      expect(error.message).to include('Invalid response')
+    end
+  end
+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/auth/dsl_spec.rb

@@ -15,15 +15,15 @@ describe Grape::Middleware::Auth::DSL do
 
   describe '.auth' do
     it 'stets auth parameters' do
-      expect(subject).to receive(:use).with(Grape::Middleware::Auth::Base, settings)
+      expect(subject.base_instance).to receive(:use).with(Grape::Middleware::Auth::Base, settings)
 
       subject.auth :http_digest, realm: settings[:realm], opaque: settings[:opaque], &settings[:proc]
       expect(subject.auth).to eq(settings)
     end
 
     it 'can be called multiple times' do
-      expect(subject).to receive(:use).with(Grape::Middleware::Auth::Base, settings)
-      expect(subject).to receive(:use).with(Grape::Middleware::Auth::Base, settings.merge(realm: 'super_secret'))
+      expect(subject.base_instance).to receive(:use).with(Grape::Middleware::Auth::Base, settings)
+      expect(subject.base_instance).to receive(:use).with(Grape::Middleware::Auth::Base, settings.merge(realm: 'super_secret'))
 
       subject.auth :http_digest, realm: settings[:realm], opaque: settings[:opaque], &settings[:proc]
       first_settings = subject.auth

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/exception_spec.rb

@@ -128,7 +128,7 @@ describe Grape::Middleware::Error do
       subject do
         Rack::Builder.app do
           use Spec::Support::EndpointFaker
-          use Grape::Middleware::Error, rescue_handlers: { NotImplementedError => -> { [200, {}, 'rescued'] } }
+          use Grape::Middleware::Error, rescue_handlers: { NotImplementedError => -> { Rack::Response.new('rescued', 200, {}) } }
           run ExceptionSpec::OtherExceptionApp
         end
       end

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)
@@ -247,7 +253,7 @@ describe Grape::Middleware::Formatter do
           let(:content_type) { 'application/atom+xml' }
 
           it 'returns a 415 HTTP error status' do
-            error = catch(:error) {
+            error = catch(:error) do
               subject.call(
                 'PATH_INFO' => '/info',
                 'REQUEST_METHOD' => method,
@@ -255,7 +261,7 @@ describe Grape::Middleware::Formatter do
                 'rack.input' => io,
                 'CONTENT_LENGTH' => io.length
               )
-            }
+            end
             expect(error[:status]).to eq(415)
             expect(error[:message]).to eq("The provided content-type 'application/atom+xml' is not supported.")
           end
@@ -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' }
@@ -407,7 +417,7 @@ describe Grape::Middleware::Formatter do
         parsers: { json: ->(_object, _env) { raise StandardError, 'fail' } }
       )
       io = StringIO.new('{invalid}')
-      error = catch(:error) {
+      error = catch(:error) do
         subject.call(
           'PATH_INFO' => '/info',
           'REQUEST_METHOD' => 'POST',
@@ -415,7 +425,7 @@ describe Grape::Middleware::Formatter do
           'rack.input' => io,
           'CONTENT_LENGTH' => io.length
         )
-      }
+      end
 
       expect(error[:message]).to eq 'fail'
       expect(error[:backtrace].size).to be >= 1

data/spec/grape/middleware/versioner/header_spec.rb

@@ -160,6 +160,12 @@ describe Grape::Middleware::Versioner::Header do
     expect(subject.call({}).first).to eq(200)
   end
 
+  it 'succeeds if :strict is set to false and given an invalid header' do
+    @options[:version_options][:strict] = false
+    expect(subject.call('HTTP_ACCEPT' => 'yaml').first).to eq(200)
+    expect(subject.call({}).first).to eq(200)
+  end
+
   context 'when :strict is set' do
     before do
       @options[:versions] = ['v1']

data/spec/grape/named_api_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'A named API' do
+  subject(:api_name) { NamedAPI.endpoints.last.options[:for].to_s }
+
+  let(:api) do
+    Class.new(Grape::API) do
+      get 'test' do
+        'response'
+      end
+    end
+  end
+
+  before { stub_const('NamedAPI', api) }
+
+  it 'can access the name of the API' do
+    expect(api_name).to eq 'NamedAPI'
+  end
+end