grape 0.16.2 → 0.17.0

data/spec/grape/integration/rack_spec.rb

@@ -22,7 +22,7 @@ describe Rack do
       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 >= 1 && ((minor == 5 && patch >= 3) || (minor >= 6))
+        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')

data/spec/grape/middleware/base_spec.rb

@@ -30,7 +30,7 @@ describe Grape::Middleware::Base do
   end
 
   context 'callbacks on error' do
-    let(:blank_app) { ->(_) { fail StandardError } }
+    let(:blank_app) { ->(_) { raise StandardError } }
 
     it 'calls #after' do
       expect(subject).to receive(:after)

data/spec/grape/middleware/exception_spec.rb

@@ -6,7 +6,7 @@ describe Grape::Middleware::Error do
     class ExceptionApp
       class << self
         def call(_env)
-          fail 'rain!'
+          raise 'rain!'
         end
       end
     end
@@ -44,7 +44,7 @@ describe Grape::Middleware::Error do
     class CustomErrorApp
       class << self
         def call(_env)
-          fail CustomError, status: 400, message: 'failed validation'
+          raise CustomError, status: 400, message: 'failed validation'
         end
       end
     end

data/spec/grape/middleware/formatter_spec.rb

@@ -17,7 +17,7 @@ describe Grape::Middleware::Formatter do
       @body = ['foo']
       @body.instance_eval do
         def to_json
-          "\"bar\""
+          '"bar"'
         end
       end
 
@@ -28,7 +28,7 @@ describe Grape::Middleware::Formatter do
       @body = { 'foos' => [{ 'bar' => 'baz' }] }
       @body.instance_eval do
         def to_json
-          "{\"foos\":[{\"bar\":\"baz\"}] }"
+          '{"foos":[{"bar":"baz"}] }'
         end
       end
 
@@ -54,7 +54,7 @@ describe Grape::Middleware::Formatter do
     end
 
     it 'rescues formatter-specific exceptions' do
-      allow(formatter).to receive(:call) { fail Grape::Exceptions::InvalidFormatter.new(String, 'xml') }
+      allow(formatter).to receive(:call) { raise Grape::Exceptions::InvalidFormatter.new(String, 'xml') }
 
       expect do
         catch(:error) { subject.call('PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json') }
@@ -62,7 +62,7 @@ describe Grape::Middleware::Formatter do
     end
 
     it 'does not rescue other exceptions' do
-      allow(formatter).to receive(:call) { fail StandardError }
+      allow(formatter).to receive(:call) { raise StandardError }
 
       expect do
         catch(:error) { subject.call('PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json') }

data/spec/grape/middleware/stack_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Grape::Middleware::Stack do
+  module StackSpec
+    class FooMiddleware; end
+    class BarMiddleware; end
+    class BlockMiddleware
+      attr_reader :block
+      def initialize(&block)
+        @block = block
+      end
+    end
+  end
+
+  let(:proc) { ->() {} }
+  let(:others) { [[:use, StackSpec::BarMiddleware], [:insert_before, StackSpec::BarMiddleware, StackSpec::BlockMiddleware, proc]] }
+
+  subject { Grape::Middleware::Stack.new }
+
+  before do
+    subject.use StackSpec::FooMiddleware
+  end
+
+  describe '#use' do
+    it 'pushes a middleware class onto the stack' do
+      expect { subject.use StackSpec::BarMiddleware }
+        .to change { subject.size }.by(1)
+      expect(subject.last).to eq(StackSpec::BarMiddleware)
+    end
+
+    it 'pushes a middleware class with arguments onto the stack' do
+      expect { subject.use StackSpec::BarMiddleware, false, my_arg: 42 }
+        .to change { subject.size }.by(1)
+      expect(subject.last).to eq(StackSpec::BarMiddleware)
+      expect(subject.last.args).to eq([false, { my_arg: 42 }])
+    end
+
+    it 'pushes a middleware class with block arguments onto the stack' do
+      expect { subject.use StackSpec::BlockMiddleware, &proc }
+        .to change { subject.size }.by(1)
+      expect(subject.last).to eq(StackSpec::BlockMiddleware)
+      expect(subject.last.args).to eq([])
+      expect(subject.last.block).to eq(proc)
+    end
+  end
+
+  describe '#insert' do
+    it 'inserts a middleware class at the integer index' do
+      expect { subject.insert 0, StackSpec::BarMiddleware }
+        .to change { subject.size }.by(1)
+      expect(subject[0]).to eq(StackSpec::BarMiddleware)
+      expect(subject[1]).to eq(StackSpec::FooMiddleware)
+    end
+  end
+
+  describe '#insert_before' do
+    it 'inserts a middleware before another middleware class' do
+      expect { subject.insert_before StackSpec::FooMiddleware, StackSpec::BarMiddleware }
+        .to change { subject.size }.by(1)
+      expect(subject[0]).to eq(StackSpec::BarMiddleware)
+      expect(subject[1]).to eq(StackSpec::FooMiddleware)
+    end
+
+    it 'raises an error on an invalid index' do
+      expect { subject.insert_before StackSpec::BlockMiddleware, StackSpec::BarMiddleware }
+        .to raise_error(RuntimeError, 'No such middleware to insert before: StackSpec::BlockMiddleware')
+    end
+  end
+
+  describe '#insert_after' do
+    it 'inserts a middleware after another middleware class' do
+      expect { subject.insert_after StackSpec::FooMiddleware, StackSpec::BarMiddleware }
+        .to change { subject.size }.by(1)
+      expect(subject[1]).to eq(StackSpec::BarMiddleware)
+      expect(subject[0]).to eq(StackSpec::FooMiddleware)
+    end
+
+    it 'raises an error on an invalid index' do
+      expect { subject.insert_after StackSpec::BlockMiddleware, StackSpec::BarMiddleware }
+        .to raise_error(RuntimeError, 'No such middleware to insert after: StackSpec::BlockMiddleware')
+    end
+  end
+
+  describe '#merge_with' do
+    it 'applies a collection of operations and middlewares' do
+      expect { subject.merge_with(others) }
+        .to change { subject.size }.by(2)
+      expect(subject[0]).to eq(StackSpec::FooMiddleware)
+      expect(subject[1]).to eq(StackSpec::BlockMiddleware)
+      expect(subject[2]).to eq(StackSpec::BarMiddleware)
+    end
+  end
+
+  describe '#build' do
+    it 'returns a rack builder instance' do
+      expect(subject.build).to be_instance_of(Rack::Builder)
+    end
+
+    context 'when @others are present' do
+      let(:others) { [[:insert_after, Grape::Middleware::Formatter, StackSpec::BarMiddleware]] }
+
+      it 'applies the middleware specs stored in @others' do
+        subject.concat others
+        subject.use Grape::Middleware::Formatter
+        subject.build
+        expect(subject[0]).to eq StackSpec::FooMiddleware
+        expect(subject[1]).to eq Grape::Middleware::Formatter
+        expect(subject[2]).to eq StackSpec::BarMiddleware
+      end
+    end
+  end
+
+  describe '#concat' do
+    it 'adds non :use specs to @others' do
+      expect { subject.concat others }.to change(subject, :others).from([]).to([[others.last]])
+    end
+
+    it 'calls +merge_with+ with the :use specs' do
+      expect(subject).to receive(:merge_with).with [[:use, StackSpec::BarMiddleware]]
+      subject.concat others
+    end
+  end
+end

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

@@ -263,13 +263,13 @@ describe Grape::Middleware::Versioner::Header do
   end
 
   context 'when there are multiple versions with complex vendor specified with rescue_from :all' do
-    subject {
+    subject do
       Class.new(Grape::API) do
         rescue_from :all
       end
-    }
+    end
 
-    let(:v1_app) {
+    let(:v1_app) do
       Class.new(Grape::API) do
         version 'v1', using: :header, vendor: 'test.a-cool_resource', cascade: false, strict: true
         content_type :v1_test, 'application/vnd.test.a-cool_resource-v1+json'
@@ -282,9 +282,9 @@ describe Grape::Middleware::Versioner::Header do
           end
         end
       end
-    }
+    end
 
-    let(:v2_app) {
+    let(:v2_app) do
       Class.new(Grape::API) do
         version 'v2', using: :header, vendor: 'test.a-cool_resource', strict: true
         content_type :v2_test, 'application/vnd.test.a-cool_resource-v2+json'
@@ -297,7 +297,7 @@ describe Grape::Middleware::Versioner::Header do
           end
         end
       end
-    }
+    end
 
     def app
       subject.mount v2_app

data/spec/grape/request_spec.rb

@@ -4,47 +4,47 @@ module Grape
   describe Request do
     let(:default_method) { 'GET' }
     let(:default_params) { {} }
-    let(:default_options) {
+    let(:default_options) do
       {
         method: method,
         params: params
       }
-    }
-    let(:default_env) {
+    end
+    let(:default_env) do
       Rack::MockRequest.env_for('/', options)
-    }
+    end
     let(:method) { default_method }
     let(:params) { default_params }
     let(:options) { default_options }
     let(:env) { default_env }
 
-    let(:request) {
+    let(:request) do
       Grape::Request.new(env)
-    }
+    end
 
     describe '#params' do
-      let(:params) {
+      let(:params) do
         {
           a: '123',
           b: 'xyz'
         }
-      }
+      end
 
       it 'returns params' do
         expect(request.params).to eq('a' => '123', 'b' => 'xyz')
       end
 
       describe 'with grape.routing_args' do
-        let(:options) {
+        let(:options) do
           default_options.merge('grape.routing_args' => routing_args)
-        }
-        let(:routing_args) {
+        end
+        let(:routing_args) do
           {
             version: '123',
             route_info: '456',
             c: 'ccc'
           }
-        }
+        end
 
         it 'cuts version and route_info' do
           expect(request.params).to eq('a' => '123', 'b' => 'xyz', 'c' => 'ccc')
@@ -53,16 +53,16 @@ module Grape
     end
 
     describe '#headers' do
-      let(:options) {
+      let(:options) do
         default_options.merge(request_headers)
-      }
+      end
 
       describe 'with http headers in env' do
-        let(:request_headers) {
+        let(:request_headers) do
           {
             'HTTP_X_GRAPE_IS_COOL' => 'yeah'
           }
-        }
+        end
 
         it 'cuts HTTP_ prefix and capitalizes header name words' do
           expect(request.headers).to eq('X-Grape-Is-Cool' => 'yeah')
@@ -70,11 +70,11 @@ module Grape
       end
 
       describe 'with non-HTTP_* stuff in env' do
-        let(:request_headers) {
+        let(:request_headers) do
           {
             'HTP_X_GRAPE_ENTITY_TOO' => 'but now we are testing Grape'
           }
-        }
+        end
 
         it 'does not include them' do
           expect(request.headers).to eq({})
@@ -82,14 +82,14 @@ module Grape
       end
 
       describe 'with symbolic header names' do
-        let(:request_headers) {
+        let(:request_headers) do
           {
             HTTP_GRAPE_LIKES_SYMBOLIC: 'it is true'
           }
-        }
-        let(:env) {
+        end
+        let(:env) do
           default_env.merge(request_headers)
-        }
+        end
 
         it 'converts them to string' do
           expect(request.headers).to eq('Grape-Likes-Symbolic' => 'it is true')

data/spec/grape/util/inheritable_setting_spec.rb

@@ -12,6 +12,7 @@ module Grape
           settings.namespace[:namespace_thing] = :namespace_foo_bar
           settings.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar
           settings.namespace_stackable[:namespace_stackable_thing] = :namespace_stackable_foo_bar
+          settings.namespace_reverse_stackable[:namespace_reverse_stackable_thing] = :namespace_reverse_stackable_foo_bar
           settings.route[:route_thing] = :route_foo_bar
         end
       end
@@ -21,6 +22,7 @@ module Grape
           settings.namespace[:namespace_thing] = :namespace_foo_bar_other
           settings.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar_other
           settings.namespace_stackable[:namespace_stackable_thing] = :namespace_stackable_foo_bar_other
+          settings.namespace_reverse_stackable[:namespace_reverse_stackable_thing] = :namespace_reverse_stackable_foo_bar_other
           settings.route[:route_thing] = :route_foo_bar_other
         end
       end
@@ -118,6 +120,16 @@ module Grape
         end
       end
 
+      describe '#namespace_reverse_stackable' do
+        it 'works with reverse stackable values' do
+          expect(subject.namespace_reverse_stackable[:namespace_reverse_stackable_thing]).to eq [:namespace_reverse_stackable_foo_bar]
+
+          subject.inherit_from other_parent
+
+          expect(subject.namespace_reverse_stackable[:namespace_reverse_stackable_thing]).to eq [:namespace_reverse_stackable_foo_bar_other]
+        end
+      end
+
       describe '#route' do
         it 'sets a value until the next route' do
           subject.route[:some_thing] = :foo_bar
@@ -184,6 +196,14 @@ module Grape
           expect(cloned_obj.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar]
         end
 
+        it 'decouples namespace reverse stackable values' do
+          expect(cloned_obj.namespace_reverse_stackable[:namespace_reverse_stackable_thing]).to eq [:namespace_reverse_stackable_foo_bar]
+
+          subject.namespace_reverse_stackable[:namespace_reverse_stackable_thing] = :other_thing
+          expect(subject.namespace_reverse_stackable[:namespace_reverse_stackable_thing]).to eq [:other_thing, :namespace_reverse_stackable_foo_bar]
+          expect(cloned_obj.namespace_reverse_stackable[:namespace_reverse_stackable_thing]).to eq [:namespace_reverse_stackable_foo_bar]
+        end
+
         it 'decouples route values' do
           expect(cloned_obj.route[:route_thing]).to eq :route_foo_bar
 
@@ -202,6 +222,7 @@ module Grape
           subject.namespace[:namespace_thing] = :namespace_foo_bar
           subject.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar
           subject.namespace_stackable[:namespace_stackable_thing] = [:namespace_stackable_foo_bar]
+          subject.namespace_reverse_stackable[:namespace_reverse_stackable_thing] = [:namespace_reverse_stackable_foo_bar]
           subject.route[:route_thing] = :route_foo_bar
 
           expect(subject.to_hash).to include(global: { global_thing: :global_foo_bar })
@@ -209,6 +230,8 @@ module Grape
           expect(subject.to_hash).to include(namespace_inheritable: {
                                                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] })
           expect(subject.to_hash).to include(route: { route_thing: :route_foo_bar })
         end
       end

data/spec/grape/util/reverse_stackable_values_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+module Grape
+  module Util
+    describe ReverseStackableValues do
+      let(:parent) { described_class.new }
+      subject { described_class.new(parent) }
+
+      describe '#keys' do
+        it 'returns all keys' do
+          subject[:some_thing] = :foo_bar
+          subject[:some_thing_else] = :foo_bar
+          expect(subject.keys).to eq [:some_thing, :some_thing_else].sort
+        end
+
+        it 'returns merged keys with parent' do
+          parent[:some_thing] = :foo
+          parent[:some_thing_else] = :foo
+
+          subject[:some_thing] = :foo_bar
+          subject[:some_thing_more] = :foo_bar
+
+          expect(subject.keys).to eq [:some_thing, :some_thing_else, :some_thing_more].sort
+        end
+      end
+
+      describe '#delete' do
+        it 'deletes a key' do
+          subject[:some_thing] = :new_foo_bar
+          subject.delete :some_thing
+          expect(subject[:some_thing]).to eq []
+        end
+
+        it 'does not delete parent values' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = :new_foo_bar
+          subject.delete :some_thing
+          expect(subject[:some_thing]).to eq [:foo]
+        end
+      end
+
+      describe '#[]' do
+        it 'returns an array of values' do
+          subject[:some_thing] = :foo
+          expect(subject[:some_thing]).to eq [:foo]
+        end
+
+        it 'returns parent value when no value is set' do
+          parent[:some_thing] = :foo
+          expect(subject[:some_thing]).to eq [:foo]
+        end
+
+        it 'combines parent and actual values (actual first)' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = :foo_bar
+          expect(subject[:some_thing]).to eq [:foo_bar, :foo]
+        end
+
+        it 'parent values are not changed' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = :foo_bar
+          expect(parent[:some_thing]).to eq [:foo]
+        end
+      end
+
+      describe '#[]=' do
+        it 'sets a value' do
+          subject[:some_thing] = :foo
+          expect(subject[:some_thing]).to eq [:foo]
+        end
+
+        it 'pushes further values' do
+          subject[:some_thing] = :foo
+          subject[:some_thing] = :bar
+          expect(subject[:some_thing]).to eq [:foo, :bar]
+        end
+
+        it 'can handle array values' do
+          subject[:some_thing] = :foo
+          subject[:some_thing] = [:bar, :more]
+          expect(subject[:some_thing]).to eq [:foo, [:bar, :more]]
+
+          parent[:some_thing_else] = [:foo, :bar]
+          subject[:some_thing_else] = [:some, :bar, :foo]
+
+          expect(subject[:some_thing_else]).to eq [[:some, :bar, :foo], [:foo, :bar]]
+        end
+      end
+
+      describe '#to_hash' do
+        it 'returns a Hash representation' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = [:bar, :more]
+          subject[:some_thing_more] = :foo_bar
+          expect(subject.to_hash).to eq(
+            some_thing: [[:bar, :more], :foo],
+            some_thing_more: [:foo_bar]
+          )
+        end
+      end
+
+      describe '#clone' do
+        let(:obj_cloned) { subject.clone }
+        it 'copies all values' do
+          parent = described_class.new
+          child = described_class.new parent
+          grandchild = described_class.new child
+
+          parent[:some_thing] = :foo
+          child[:some_thing] = [:bar, :more]
+          grandchild[:some_thing] = :grand_foo_bar
+          grandchild[:some_thing_more] = :foo_bar
+
+          expect(grandchild.clone.to_hash).to eq(
+            some_thing: [:grand_foo_bar, [:bar, :more], :foo],
+            some_thing_more: [:foo_bar]
+          )
+        end
+
+        context 'complex (i.e. not primitive) data types (ex. middleware, please see bug #930)' do
+          let(:middleware) { double }
+
+          before { subject[:middleware] = middleware }
+
+          it 'copies values; does not duplicate them' do
+            expect(obj_cloned[:middleware]).to eq [middleware]
+          end
+        end
+      end
+    end
+  end
+end