grape 1.6.0 → 1.6.2

data/spec/grape/middleware/auth/strategies_spec.rb

@@ -42,7 +42,17 @@ describe Grape::Middleware::Auth::Strategies do
     end
 
     module StrategiesSpec
-      class Test < Grape::API
+      class PasswordHashed < Grape::API
+        http_digest(realm: { realm: 'Test Api', opaque: 'secret', passwords_hashed: true }) do |username|
+          { 'foo' => Digest::MD5.hexdigest(['foo', 'Test Api', 'bar'].join(':')) }[username]
+        end
+
+        get '/test' do
+          [{ hey: 'you' }, { there: 'bar' }, { foo: 'baz' }]
+        end
+      end
+
+      class PasswordIsNotHashed < Grape::API
         http_digest(realm: 'Test Api', opaque: 'secret') do |username|
           { 'foo' => 'bar' }[username]
         end
@@ -53,30 +63,60 @@ describe Grape::Middleware::Auth::Strategies do
       end
     end
 
-    def app
-      StrategiesSpec::Test
-    end
+    context 'when password is hashed' do
+      def app
+        StrategiesSpec::PasswordHashed
+      end
 
-    it 'is a digest authentication challenge' do
-      get '/test'
-      expect(last_response).to be_challenge
-    end
+      it 'is a digest authentication challenge' do
+        get '/test'
+        expect(last_response).to be_challenge
+      end
 
-    it 'throws a 401 if no auth is given' do
-      get '/test'
-      expect(last_response.status).to eq(401)
-    end
+      it 'throws a 401 if no auth is given' do
+        get '/test'
+        expect(last_response.status).to eq(401)
+      end
 
-    it 'authenticates if given valid creds' do
-      digest_authorize 'foo', 'bar'
-      get '/test'
-      expect(last_response.status).to eq(200)
+      it 'authenticates if given valid creds' do
+        digest_authorize 'foo', 'bar'
+        get '/test'
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'throws a 401 if given invalid creds' do
+        digest_authorize 'bar', 'foo'
+        get '/test'
+        expect(last_response.status).to eq(401)
+      end
     end
 
-    it 'throws a 401 if given invalid creds' do
-      digest_authorize 'bar', 'foo'
-      get '/test'
-      expect(last_response.status).to eq(401)
+    context 'when password is not hashed' do
+      def app
+        StrategiesSpec::PasswordIsNotHashed
+      end
+
+      it 'is a digest authentication challenge' do
+        get '/test'
+        expect(last_response).to be_challenge
+      end
+
+      it 'throws a 401 if no auth is given' do
+        get '/test'
+        expect(last_response.status).to eq(401)
+      end
+
+      it 'authenticates if given valid creds' do
+        digest_authorize 'foo', 'bar'
+        get '/test'
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'throws a 401 if given invalid creds' do
+        digest_authorize 'bar', 'foo'
+        get '/test'
+        expect(last_response.status).to eq(401)
+      end
     end
   end
 end

data/spec/grape/middleware/base_spec.rb

@@ -3,7 +3,8 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Base do
-  subject { Grape::Middleware::Base.new(blank_app) }
+  subject { described_class.new(blank_app) }
+
   let(:blank_app) { ->(_) { [200, {}, 'Hi there.'] } }
 
   before do
@@ -20,6 +21,8 @@ describe Grape::Middleware::Base do
   end
 
   context 'callbacks' do
+    after { subject.call!({}) }
+
     it 'calls #before' do
       expect(subject).to receive(:before)
     end
@@ -27,8 +30,6 @@ describe Grape::Middleware::Base do
     it 'calls #after' do
       expect(subject).to receive(:after)
     end
-
-    after { subject.call!({}) }
   end
 
   context 'callbacks on error' do
@@ -58,7 +59,7 @@ describe Grape::Middleware::Base do
     context 'with patched warnings' do
       before do
         @warnings = warnings = []
-        allow_any_instance_of(Grape::Middleware::Base).to receive(:warn) { |m| warnings << m }
+        allow_any_instance_of(described_class).to receive(:warn) { |m| warnings << m }
         allow(subject).to receive(:after).and_raise(StandardError)
       end
 
@@ -75,49 +76,57 @@ describe Grape::Middleware::Base do
   end
 
   describe '#response' do
-    subject { Grape::Middleware::Base.new(response) }
+    subject do
+      puts described_class
+      described_class.new(response)
+    end
 
-    context Array do
+    before { subject.call({}) }
+
+    context 'when Array' do
       let(:response) { ->(_) { [204, { abc: 1 }, 'test'] } }
 
       it 'status' do
-        subject.call({})
         expect(subject.response.status).to eq(204)
       end
 
       it 'body' do
-        subject.call({})
         expect(subject.response.body).to eq(['test'])
       end
 
       it 'header' do
-        subject.call({})
         expect(subject.response.header).to have_key(:abc)
       end
+
+      it 'returns the memoized Rack::Response instance' do
+        expect(subject.response).to be(subject.response)
+      end
     end
 
-    context Rack::Response do
+    context 'when Rack::Response' do
       let(:response) { ->(_) { Rack::Response.new('test', 204, abc: 1) } }
 
       it 'status' do
-        subject.call({})
         expect(subject.response.status).to eq(204)
       end
 
       it 'body' do
-        subject.call({})
         expect(subject.response.body).to eq(['test'])
       end
 
       it 'header' do
-        subject.call({})
         expect(subject.response.header).to have_key(:abc)
       end
+
+      it 'returns the memoized Rack::Response instance' do
+        expect(subject.response).to be(subject.response)
+      end
     end
   end
 
   describe '#context' do
-    subject { Grape::Middleware::Base.new(blank_app) }
+    subject { described_class.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')
@@ -126,7 +135,7 @@ describe Grape::Middleware::Base do
 
   context 'options' do
     it 'persists options passed at initialization' do
-      expect(Grape::Middleware::Base.new(blank_app, abc: true).options[:abc]).to be true
+      expect(described_class.new(blank_app, abc: true).options[:abc]).to be true
     end
 
     context 'defaults' do

data/spec/grape/middleware/error_spec.rb

@@ -62,6 +62,7 @@ describe Grape::Middleware::Error do
 
   context 'with http code' do
     let(:options) {  { default_message: 'Aww, hamburgers.' } }
+
     it 'adds the status code if wanted' do
       ErrorSpec::ErrApp.error = { message: { code: 200 } }
       get '/'

data/spec/grape/middleware/exception_spec.rb

@@ -3,76 +3,82 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Error do
-  # raises a text exception
-  module ExceptionSpec
-    class ExceptionApp
+  let(:exception_app) do
+    Class.new do
       class << self
         def call(_env)
           raise 'rain!'
         end
       end
     end
+  end
 
-    # raises a non-StandardError (ScriptError) exception
-    class OtherExceptionApp
+  let(:other_exception_app) do
+    Class.new do
       class << self
         def call(_env)
           raise NotImplementedError, 'snow!'
         end
       end
     end
+  end
 
-    # raises a hash error
-    class ErrorHashApp
+  let(:custom_error_app) do
+    Class.new do
       class << self
-        def error!(message, status)
-          throw :error, message: { error: message, detail: 'missing widget' }, status: status
-        end
+        class CustomError < Grape::Exceptions::Base; end
 
         def call(_env)
-          error!('rain!', 401)
+          raise CustomError.new(status: 400, message: 'failed validation')
         end
       end
     end
+  end
 
-    # raises an error!
-    class AccessDeniedApp
+  let(:error_hash_app) do
+    Class.new do
       class << self
         def error!(message, status)
-          throw :error, message: message, status: status
+          throw :error, message: { error: message, detail: 'missing widget' }, status: status
         end
 
         def call(_env)
-          error!('Access Denied', 401)
+          error!('rain!', 401)
         end
       end
     end
+  end
 
-    # raises a custom error
-    class CustomError < Grape::Exceptions::Base
-    end
-
-    class CustomErrorApp
+  let(:access_denied_app) do
+    Class.new do
       class << self
+        def error!(message, status)
+          throw :error, message: message, status: status
+        end
+
         def call(_env)
-          raise CustomError.new(status: 400, message: 'failed validation')
+          error!('Access Denied', 401)
         end
       end
     end
   end
 
-  def app
-    subject
+  let(:app) do
+    builder = Rack::Builder.new
+    builder.use Spec::Support::EndpointFaker
+    if options.any?
+      builder.use described_class, options
+    else
+      builder.use described_class
+    end
+    builder.run running_app
+    builder.to_app
   end
 
   context 'with defaults' do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error
-        run ExceptionSpec::ExceptionApp
-      end
-    end
+    let(:running_app) { exception_app }
+    let(:options) { {} }
+
     it 'does not trap errors by default' do
       expect { get '/' }.to raise_error(RuntimeError, 'rain!')
     end
@@ -80,17 +86,14 @@ describe Grape::Middleware::Error do
 
   context 'with rescue_all' do
     context 'StandardError exception' do
-      subject do
-        Rack::Builder.app do
-          use Spec::Support::EndpointFaker
-          use Grape::Middleware::Error, rescue_all: true
-          run ExceptionSpec::ExceptionApp
-        end
-      end
+      let(:running_app) { exception_app }
+      let(:options) { { rescue_all: true } }
+
       it 'sets the message appropriately' do
         get '/'
         expect(last_response.body).to eq('rain!')
       end
+
       it 'defaults to a 500 status' do
         get '/'
         expect(last_response.status).to eq(500)
@@ -98,13 +101,9 @@ describe Grape::Middleware::Error do
     end
 
     context 'Non-StandardError exception' do
-      subject do
-        Rack::Builder.app do
-          use Spec::Support::EndpointFaker
-          use Grape::Middleware::Error, rescue_all: true
-          run ExceptionSpec::OtherExceptionApp
-        end
-      end
+      let(:running_app) { other_exception_app }
+      let(:options) { { rescue_all: true } }
+
       it 'does not trap errors other than StandardError' do
         expect { get '/' }.to raise_error(NotImplementedError, 'snow!')
       end
@@ -113,13 +112,9 @@ describe Grape::Middleware::Error do
 
   context 'Non-StandardError exception with a provided rescue handler' do
     context 'default error response' do
-      subject do
-        Rack::Builder.app do
-          use Spec::Support::EndpointFaker
-          use Grape::Middleware::Error, rescue_handlers: { NotImplementedError => nil }
-          run ExceptionSpec::OtherExceptionApp
-        end
-      end
+      let(:running_app) { other_exception_app }
+      let(:options) { { rescue_handlers: { NotImplementedError => nil } } }
+
       it 'rescues the exception using the default handler' do
         get '/'
         expect(last_response.body).to eq('snow!')
@@ -127,13 +122,9 @@ describe Grape::Middleware::Error do
     end
 
     context 'custom error response' do
-      subject do
-        Rack::Builder.app do
-          use Spec::Support::EndpointFaker
-          use Grape::Middleware::Error, rescue_handlers: { NotImplementedError => -> { Rack::Response.new('rescued', 200, {}) } }
-          run ExceptionSpec::OtherExceptionApp
-        end
-      end
+      let(:running_app) { other_exception_app }
+      let(:options) { { rescue_handlers: { NotImplementedError => -> { Rack::Response.new('rescued', 200, {}) } } } }
+
       it 'rescues the exception using the provided handler' do
         get '/'
         expect(last_response.body).to eq('rescued')
@@ -142,13 +133,9 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true, default_status: 500
-        run ExceptionSpec::ExceptionApp
-      end
-    end
+    let(:running_app) { exception_app }
+    let(:options) { { rescue_all: true, default_status: 500 } }
+
     it 'is possible to specify a different default status code' do
       get '/'
       expect(last_response.status).to eq(500)
@@ -156,13 +143,9 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true, format: :json
-        run ExceptionSpec::ExceptionApp
-      end
-    end
+    let(:running_app) { exception_app }
+    let(:options) { { rescue_all: true, format: :json } }
+
     it 'is possible to return errors in json format' do
       get '/'
       expect(last_response.body).to eq('{"error":"rain!"}')
@@ -170,13 +153,9 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true, format: :json
-        run ExceptionSpec::ErrorHashApp
-      end
-    end
+    let(:running_app) { error_hash_app }
+    let(:options) { { rescue_all: true, format: :json } }
+
     it 'is possible to return hash errors in json format' do
       get '/'
       expect(['{"error":"rain!","detail":"missing widget"}',
@@ -185,13 +164,9 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true, format: :jsonapi
-        run ExceptionSpec::ExceptionApp
-      end
-    end
+    let(:running_app) { exception_app }
+    let(:options) { { rescue_all: true, format: :jsonapi } }
+
     it 'is possible to return errors in jsonapi format' do
       get '/'
       expect(last_response.body).to eq('{&quot;error&quot;:&quot;rain!&quot;}')
@@ -199,13 +174,8 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true, format: :jsonapi
-        run ExceptionSpec::ErrorHashApp
-      end
-    end
+    let(:running_app) { error_hash_app }
+    let(:options) { { rescue_all: true, format: :jsonapi } }
 
     it 'is possible to return hash errors in jsonapi format' do
       get '/'
@@ -215,13 +185,9 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true, format: :xml
-        run ExceptionSpec::ExceptionApp
-      end
-    end
+    let(:running_app) { exception_app }
+    let(:options) { { rescue_all: true, format: :xml } }
+
     it 'is possible to return errors in xml format' do
       get '/'
       expect(last_response.body).to eq("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<error>\n  <message>rain!</message>\n</error>\n")
@@ -229,13 +195,9 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true, format: :xml
-        run ExceptionSpec::ErrorHashApp
-      end
-    end
+    let(:running_app) { error_hash_app }
+    let(:options) { { rescue_all: true, format: :xml } }
+
     it 'is possible to return hash errors in xml format' do
       get '/'
       expect(["<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<error>\n  <detail>missing widget</detail>\n  <error>rain!</error>\n</error>\n",
@@ -244,20 +206,19 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error,
-            rescue_all: true,
-            format: :custom,
-            error_formatters: {
-              custom: lambda do |message, _backtrace, _options, _env, _original_exception|
-                { custom_formatter: message }.inspect
-              end
-            }
-        run ExceptionSpec::ExceptionApp
-      end
+    let(:running_app) { exception_app }
+    let(:options) do
+      {
+        rescue_all: true,
+        format: :custom,
+        error_formatters: {
+          custom: lambda do |message, _backtrace, _options, _env, _original_exception|
+            { custom_formatter: message }.inspect
+          end
+        }
+      }
     end
+
     it 'is possible to specify a custom formatter' do
       get '/'
       expect(last_response.body).to eq('{:custom_formatter=&gt;&quot;rain!&quot;}')
@@ -265,13 +226,9 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error
-        run ExceptionSpec::AccessDeniedApp
-      end
-    end
+    let(:running_app) { access_denied_app }
+    let(:options) { {} }
+
     it 'does not trap regular error! codes' do
       get '/'
       expect(last_response.status).to eq(401)
@@ -279,13 +236,9 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: false
-        run ExceptionSpec::CustomErrorApp
-      end
-    end
+    let(:running_app) { custom_error_app }
+    let(:options) { { rescue_all: false } }
+
     it 'responds to custom Grape exceptions appropriately' do
       get '/'
       expect(last_response.status).to eq(400)
@@ -294,16 +247,15 @@ describe Grape::Middleware::Error do
   end
 
   context 'with rescue_options :backtrace and :exception set to true' do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error,
-            rescue_all: true,
-            format: :json,
-            rescue_options: { backtrace: true, original_exception: true }
-        run ExceptionSpec::ExceptionApp
-      end
+    let(:running_app) { exception_app }
+    let(:options) do
+      {
+        rescue_all: true,
+        format: :json,
+        rescue_options: { backtrace: true, original_exception: true }
+      }
     end
+
     it 'is possible to return the backtrace and the original exception in json format' do
       get '/'
       expect(last_response.body).to include('error', 'rain!', 'backtrace', 'original_exception', 'RuntimeError')
@@ -311,16 +263,15 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error,
-            rescue_all: true,
-            format: :xml,
-            rescue_options: { backtrace: true, original_exception: true }
-        run ExceptionSpec::ExceptionApp
-      end
+    let(:running_app) { exception_app }
+    let(:options) do
+      {
+        rescue_all: true,
+        format: :xml,
+        rescue_options: { backtrace: true, original_exception: true }
+      }
     end
+
     it 'is possible to return the backtrace and the original exception in xml format' do
       get '/'
       expect(last_response.body).to include('error', 'rain!', 'backtrace', 'original-exception', 'RuntimeError')
@@ -328,16 +279,15 @@ describe Grape::Middleware::Error do
   end
 
   context do
-    subject do
-      Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error,
-            rescue_all: true,
-            format: :txt,
-            rescue_options: { backtrace: true, original_exception: true }
-        run ExceptionSpec::ExceptionApp
-      end
+    let(:running_app) { exception_app }
+    let(:options) do
+      {
+        rescue_all: true,
+        format: :txt,
+        rescue_options: { backtrace: true, original_exception: true }
+      }
     end
+
     it 'is possible to return the backtrace and the original exception in txt format' do
       get '/'
       expect(last_response.body).to include('error', 'rain!', 'backtrace', 'original exception', 'RuntimeError')