grape 0.18.0 → 0.19.0

data/spec/grape/dsl/desc_spec.rb

@@ -34,8 +34,7 @@ module Grape
                       XOptionalHeader: {
                         description: 'Not really needed',
                         required: false
-                      }
-                     ]
+                      }]
           }
 
           subject.desc 'The description' do
@@ -51,8 +50,7 @@ module Grape
                      XOptionalHeader: {
                        description: 'Not really needed',
                        required: false
-                     }
-                    ]
+                     }]
           end
 
           expect(subject.namespace_setting(:description)).to eq(expected_options)

data/spec/grape/dsl/inside_route_spec.rb

@@ -91,7 +91,7 @@ describe Grape::Endpoint do
   end
 
   describe '#status' do
-    %w(GET PUT DELETE OPTIONS).each do |method|
+    %w(GET PUT OPTIONS).each do |method|
       it 'defaults to 200 on GET' do
         request = Grape::Request.new(Rack::MockRequest.env_for('/', method: method))
         expect(subject).to receive(:request).and_return(request)
@@ -105,6 +105,12 @@ describe Grape::Endpoint do
       expect(subject.status).to eq 201
     end
 
+    it 'defaults to 204 on DELETE' do
+      request = Grape::Request.new(Rack::MockRequest.env_for('/', method: 'DELETE'))
+      expect(subject).to receive(:request).and_return(request)
+      expect(subject.status).to eq 204
+    end
+
     it 'returns status set' do
       subject.status 501
       expect(subject.status).to eq 501
@@ -302,22 +308,22 @@ describe Grape::Endpoint do
     end
 
     describe 'multiple entities' do
-      let(:entity_mock1) do
-        entity_mock1 = Object.new
-        allow(entity_mock1).to receive(:represent).and_return(dummy1: 'dummy1')
-        entity_mock1
+      let(:entity_mock_one) do
+        entity_mock_one = Object.new
+        allow(entity_mock_one).to receive(:represent).and_return(dummy1: 'dummy1')
+        entity_mock_one
       end
 
-      let(:entity_mock2) do
-        entity_mock2 = Object.new
-        allow(entity_mock2).to receive(:represent).and_return(dummy2: 'dummy2')
-        entity_mock2
+      let(:entity_mock_two) do
+        entity_mock_two = Object.new
+        allow(entity_mock_two).to receive(:represent).and_return(dummy2: 'dummy2')
+        entity_mock_two
       end
 
       describe 'instance' do
         before do
-          subject.present 'dummy1', with: entity_mock1
-          subject.present 'dummy2', with: entity_mock2
+          subject.present 'dummy1', with: entity_mock_one
+          subject.present 'dummy2', with: entity_mock_two
         end
 
         it 'presents both dummy objects' do
@@ -328,23 +334,23 @@ describe Grape::Endpoint do
     end
 
     describe 'non mergeable entity' do
-      let(:entity_mock1) do
-        entity_mock1 = Object.new
-        allow(entity_mock1).to receive(:represent).and_return(dummy1: 'dummy1')
-        entity_mock1
+      let(:entity_mock_one) do
+        entity_mock_one = Object.new
+        allow(entity_mock_one).to receive(:represent).and_return(dummy1: 'dummy1')
+        entity_mock_one
       end
 
-      let(:entity_mock2) do
-        entity_mock2 = Object.new
-        allow(entity_mock2).to receive(:represent).and_return('not a hash')
-        entity_mock2
+      let(:entity_mock_two) do
+        entity_mock_two = Object.new
+        allow(entity_mock_two).to receive(:represent).and_return('not a hash')
+        entity_mock_two
       end
 
       describe 'instance' do
         it 'fails' do
-          subject.present 'dummy1', with: entity_mock1
+          subject.present 'dummy1', with: entity_mock_one
           expect do
-            subject.present 'dummy2', with: entity_mock2
+            subject.present 'dummy2', with: entity_mock_two
           end.to raise_error ArgumentError, 'Representation of type String cannot be merged.'
         end
       end
@@ -356,7 +362,8 @@ describe Grape::Endpoint do
 
     it 'is not available by default' do
       expect { subject.declared({}) }.to raise_error(
-        Grape::DSL::InsideRoute::MethodNotYetAvailable)
+        Grape::DSL::InsideRoute::MethodNotYetAvailable
+      )
     end
   end
 end

data/spec/grape/dsl/parameters_spec.rb

@@ -31,10 +31,15 @@ module Grape
           @validates
         end
 
+        def new_group_scope(args)
+          @group = args.clone.first
+          yield
+        end
+
         def extract_message_option(attrs)
           return nil unless attrs.is_a?(Array)
           opts = attrs.last.is_a?(Hash) ? attrs.pop : {}
-          (opts.key?(:message) && !opts[:message].nil?) ? opts.delete(:message) : nil
+          opts.key?(:message) && !opts[:message].nil? ? opts.delete(:message) : nil
         end
       end
     end
@@ -92,6 +97,15 @@ module Grape
         end
       end
 
+      describe '#with' do
+        it 'creates a scope with group attributes' do
+          subject.with(type: Integer) { subject.optional :id, desc: 'Identity.' }
+
+          expect(subject.validate_attributes_reader).to eq([[:id], { type: Integer, desc: 'Identity.' }])
+          expect(subject.push_declared_params_reader).to eq([[:id]])
+        end
+      end
+
       describe '#mutually_exclusive' do
         it 'adds an mutally exclusive parameter validation' do
           subject.mutually_exclusive :media, :audio

data/spec/grape/endpoint_spec.rb

@@ -268,7 +268,8 @@ describe Grape::Endpoint do
       subject.get('/declared') { declared(params) }
 
       expect { get('/declared') }.to raise_error(
-        Grape::DSL::InsideRoute::MethodNotYetAvailable)
+        Grape::DSL::InsideRoute::MethodNotYetAvailable
+      )
     end
 
     it 'has as many keys as there are declared params' do
@@ -1094,32 +1095,65 @@ describe Grape::Endpoint do
   end
 
   context 'anchoring' do
-    verbs = %w(post get head delete put options patch)
+    describe 'delete 204' do
+      it 'allows for the anchoring option with a delete method' do
+        subject.send(:delete, '/example', anchor: true) {}
+        send(:delete, '/example/and/some/more')
+        expect(last_response.status).to eql 404
+      end
 
-    verbs.each do |verb|
-      it "allows for the anchoring option with a #{verb.upcase} method" do
-        subject.send(verb, '/example', anchor: true) do
-          verb
-        end
-        send(verb, '/example/and/some/more')
+      it 'anchors paths by default for the delete method' do
+        subject.send(:delete, '/example') {}
+        send(:delete, '/example/and/some/more')
         expect(last_response.status).to eql 404
       end
 
-      it "anchors paths by default for the #{verb.upcase} method" do
-        subject.send(verb, '/example') do
-          verb
+      it 'responds to /example/and/some/more for the non-anchored delete method' do
+        subject.send(:delete, '/example', anchor: false) {}
+        send(:delete, '/example/and/some/more')
+        expect(last_response.status).to eql 204
+        expect(last_response.body).to be_empty
+      end
+    end
+
+    describe 'delete 200, with response body' do
+      it 'responds to /example/and/some/more for the non-anchored delete method' do
+        subject.send(:delete, '/example', anchor: false) do
+          status 200
+          body 'deleted'
         end
-        send(verb, '/example/and/some/more')
-        expect(last_response.status).to eql 404
+        send(:delete, '/example/and/some/more')
+        expect(last_response.status).to eql 200
+        expect(last_response.body).not_to be_empty
       end
+    end
+
+    describe 'all other' do
+      %w(post get head put options patch).each do |verb|
+        it "allows for the anchoring option with a #{verb.upcase} method" do
+          subject.send(verb, '/example', anchor: true) do
+            verb
+          end
+          send(verb, '/example/and/some/more')
+          expect(last_response.status).to eql 404
+        end
 
-      it "responds to /example/and/some/more for the non-anchored #{verb.upcase} method" do
-        subject.send(verb, '/example', anchor: false) do
-          verb
+        it "anchors paths by default for the #{verb.upcase} method" do
+          subject.send(verb, '/example') do
+            verb
+          end
+          send(verb, '/example/and/some/more')
+          expect(last_response.status).to eql 404
+        end
+
+        it "responds to /example/and/some/more for the non-anchored #{verb.upcase} method" do
+          subject.send(verb, '/example', anchor: false) do
+            verb
+          end
+          send(verb, '/example/and/some/more')
+          expect(last_response.status).to eql verb == 'post' ? 201 : 200
+          expect(last_response.body).to eql verb == 'head' ? '' : verb
         end
-        send(verb, '/example/and/some/more')
-        expect(last_response.status).to eql verb == 'post' ? 201 : 200
-        expect(last_response.body).to eql verb == 'head' ? '' : verb
       end
     end
   end

data/spec/grape/middleware/formatter_spec.rb

@@ -4,46 +4,53 @@ describe Grape::Middleware::Formatter do
   subject { Grape::Middleware::Formatter.new(app) }
   before { allow(subject).to receive(:dup).and_return(subject) }
 
-  let(:app) { ->(_env) { [200, {}, [@body || { 'foo' => 'bar' }]] } }
+  let(:body) { { 'foo' => 'bar' } }
+  let(:app) { ->(_env) { [200, {}, [body]] } }
 
   context 'serialization' do
+    let(:body) { { 'abc' => 'def' } }
     it 'looks at the bodies for possibly serializable data' do
-      @body = { 'abc' => 'def' }
       _, _, bodies = *subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json')
-      bodies.each { |b| expect(b).to eq(MultiJson.dump(@body)) }
+      bodies.each { |b| expect(b).to eq(MultiJson.dump(body)) }
     end
 
-    it 'calls #to_json since default format is json' do
-      @body = ['foo']
-      @body.instance_eval do
-        def to_json
-          '"bar"'
+    context 'default format' do
+      let(:body) { ['foo'] }
+      it 'calls #to_json since default format is json' do
+        body.instance_eval do
+          def to_json
+            '"bar"'
+          end
         end
-      end
 
-      subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('"bar"') }
+        subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('"bar"') }
+      end
     end
 
-    it 'calls #to_json if the content type is jsonapi' do
-      @body = { 'foos' => [{ 'bar' => 'baz' }] }
-      @body.instance_eval do
-        def to_json
-          '{"foos":[{"bar":"baz"}] }'
+    context 'jsonapi' do
+      let(:body) { { 'foos' => [{ 'bar' => 'baz' }] } }
+      it 'calls #to_json if the content type is jsonapi' do
+        body.instance_eval do
+          def to_json
+            '{"foos":[{"bar":"baz"}] }'
+          end
         end
-      end
 
-      subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/vnd.api+json').to_a.last.each { |b| expect(b).to eq('{"foos":[{"bar":"baz"}] }') }
+        subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/vnd.api+json').to_a.last.each { |b| expect(b).to eq('{"foos":[{"bar":"baz"}] }') }
+      end
     end
 
-    it 'calls #to_xml if the content type is xml' do
-      @body = 'string'
-      @body.instance_eval do
-        def to_xml
-          '<bar/>'
+    context 'xml' do
+      let(:body) { 'string' }
+      it 'calls #to_xml if the content type is xml' do
+        body.instance_eval do
+          def to_xml
+            '<bar/>'
+          end
         end
-      end
 
-      subject.call('PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('<bar/>') }
+        subject.call('PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('<bar/>') }
+      end
     end
   end
 
@@ -189,10 +196,12 @@ describe Grape::Middleware::Formatter do
       _, _, body = subject.call('PATH_INFO' => '/info.custom')
       expect(body.body).to eq(['CUSTOM FORMAT'])
     end
-    it 'uses default json formatter' do
-      @body = ['blah']
-      _, _, body = subject.call('PATH_INFO' => '/info.json')
-      expect(body.body).to eq(['["blah"]'])
+    context 'default' do
+      let(:body) { ['blah'] }
+      it 'uses default json formatter' do
+        _, _, body = subject.call('PATH_INFO' => '/info.json')
+        expect(body.body).to eq(['["blah"]'])
+      end
     end
     it 'uses custom json formatter' do
       subject.options[:formatters][:json] = ->(_obj, _env) { 'CUSTOM JSON FORMAT' }
@@ -284,10 +293,10 @@ describe Grape::Middleware::Formatter do
   end
 
   context 'send file' do
-    let(:app) { ->(_env) { [200, {}, @body] } }
+    let(:body) { Grape::ServeFile::FileResponse.new('file') }
+    let(:app) { ->(_env) { [200, {}, body] } }
 
     it 'returns Grape::Uril::SendFileReponse' do
-      @body = Grape::ServeFile::FileResponse.new('file')
       env = { 'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json' }
       expect(subject.call(env)).to be_a(Grape::ServeFile::SendfileResponse)
     end

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

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Param do
   let(:app) { ->(env) { [200, env, env['api.version']] } }
-  subject { Grape::Middleware::Versioner::Param.new(app, @options || {}) }
+  let(:options) { {} }
+  subject { Grape::Middleware::Versioner::Param.new(app, options) }
 
   it 'sets the API version based on the default param (apiver)' do
     env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1' })
@@ -22,7 +23,7 @@ describe Grape::Middleware::Versioner::Param do
   end
 
   context 'with specified parameter name' do
-    before { @options = { version_options: { parameter: 'v' } } }
+    let(:options) { { version_options: { parameter: 'v' } } }
     it 'sets the API version based on the custom parameter name' do
       env = Rack::MockRequest.env_for('/awesome', params: { 'v' => 'v1' })
       expect(subject.call(env)[1]['api.version']).to eq('v1')
@@ -34,7 +35,7 @@ describe Grape::Middleware::Versioner::Param do
   end
 
   context 'with specified versions' do
-    before { @options = { versions: %w(v1 v2) } }
+    let(:options) { { versions: %w(v1 v2) } }
     it 'throws an error if a non-allowed version is specified' do
       env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v3' })
       expect(catch(:error) { subject.call(env) }[:status]).to eq(404)
@@ -45,13 +46,17 @@ describe Grape::Middleware::Versioner::Param do
     end
   end
 
-  it 'returns a 200 when no version is set (matches the first version found)' do
-    @options = {
-      versions: ['v1'],
-      version_options: { using: :header }
-    }
-    env = Rack::MockRequest.env_for('/awesome', params: {})
-    expect(subject.call(env).first).to eq(200)
+  context 'when no version is set' do
+    let(:options) do
+      {
+        versions: ['v1'],
+        version_options: { using: :header }
+      }
+    end
+    it 'returns a 200 (matches the first version found)' do
+      env = Rack::MockRequest.env_for('/awesome', params: {})
+      expect(subject.call(env).first).to eq(200)
+    end
   end
 
   context 'when there are multiple versions without a custom param' do

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

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Path do
   let(:app) { ->(env) { [200, env, env['api.version']] } }
-  subject { Grape::Middleware::Versioner::Path.new(app, @options || {}) }
+  let(:options) { {} }
+  subject { Grape::Middleware::Versioner::Path.new(app, options) }
 
   it 'sets the API version based on the first path' do
     expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
@@ -17,7 +18,7 @@ describe Grape::Middleware::Versioner::Path do
   end
 
   context 'with a pattern' do
-    before { @options = { pattern: /v./i } }
+    let(:options) { { pattern: /v./i } }
     it 'sets the version if it matches' do
       expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
     end
@@ -29,7 +30,7 @@ describe Grape::Middleware::Versioner::Path do
 
   [%w(v1 v2), [:v1, :v2], [:v1, 'v2'], ['v1', :v2]].each do |versions|
     context "with specified versions as #{versions}" do
-      before { @options = { versions: versions } }
+      let(:options) { { versions: versions } }
 
       it 'throws an error if a non-allowed version is specified' do
         expect(catch(:error) { subject.call('PATH_INFO' => '/v3/awesome') }[:status]).to eq(404)

data/spec/grape/util/inheritable_setting_spec.rb

@@ -228,7 +228,8 @@ module Grape
           expect(subject.to_hash).to include(global: { global_thing: :global_foo_bar })
           expect(subject.to_hash).to include(namespace: { namespace_thing: :namespace_foo_bar })
           expect(subject.to_hash).to include(namespace_inheritable: {
-                                               namespace_inheritable_thing: :namespace_inheritable_foo_bar })
+                                               namespace_inheritable_thing: :namespace_inheritable_foo_bar
+                                             })
           expect(subject.to_hash).to include(namespace_stackable: { namespace_stackable_thing: [:namespace_stackable_foo_bar, [:namespace_stackable_foo_bar]] })
           expect(subject.to_hash).to include(namespace_reverse_stackable:
             { namespace_reverse_stackable_thing: [[:namespace_reverse_stackable_foo_bar], :namespace_reverse_stackable_foo_bar] })

data/spec/grape/util/strict_hash_configuration_spec.rb

@@ -30,8 +30,7 @@ module Grape
         expect(subject.settings).to eq(config1: 'alpha',
                                        config2: 'beta',
                                        config3: { config4: 'gamma' },
-                                       config5: { config6: { config7: 7, config8: 8 } }
-                                      )
+                                       config5: { config6: { config7: 7, config8: 8 } })
       end
     end
   end