grape 0.8.0 → 0.9.0

data/spec/grape/endpoint_spec.rb

@@ -27,7 +27,7 @@ describe Grape::Endpoint do
       expect { get '/' }.to raise_error(NameError)
 
       Grape::Endpoint.before_each do |endpoint|
-        endpoint.stub(:current_user).and_return("Bob")
+        allow(endpoint).to receive(:current_user).and_return("Bob")
       end
 
       get '/'
@@ -45,7 +45,7 @@ describe Grape::Endpoint do
         Grape::Endpoint.new(Grape::Util::HashStack.new, {
                               path: '/',
                               method: :get
-        }, &p)
+                            }, &p)
       }.not_to raise_error
     end
   end
@@ -67,6 +67,33 @@ describe Grape::Endpoint do
       expect(last_response.status).to eq(206)
       expect(last_response.body).to eq("Hello")
     end
+
+    it 'is set as default to 200 for get' do
+      memoized_status = nil
+      subject.get('/home') do
+        memoized_status = status
+        "Hello"
+      end
+
+      get '/home'
+      expect(last_response.status).to eq(200)
+      expect(memoized_status).to eq(200)
+      expect(last_response.body).to eq("Hello")
+    end
+
+    it 'is set as default to 201 for post' do
+      memoized_status = nil
+      subject.post('/home') do
+        memoized_status = status
+        "Hello"
+      end
+
+      post '/home'
+      expect(last_response.status).to eq(201)
+      expect(memoized_status).to eq(201)
+      expect(last_response.body).to eq("Hello")
+    end
+
   end
 
   describe '#header' do
@@ -214,33 +241,37 @@ describe Grape::Endpoint do
     end
 
     it 'has as many keys as there are declared params' do
+      inner_params = nil
       subject.get '/declared' do
-        declared(params).keys.size.should == 4
+        inner_params = declared(params).keys
         ""
       end
-
       get '/declared?first=present'
       expect(last_response.status).to eq(200)
+      expect(inner_params.size).to eq(4)
     end
 
     it 'has a optional param with default value all the time' do
+      inner_params = nil
       subject.get '/declared' do
-        params[:third].should == 'third-default'
+        inner_params = declared(params)
         ""
       end
-
       get '/declared?first=one'
       expect(last_response.status).to eq(200)
+      expect(inner_params[:third]).to eql('third-default')
     end
 
     it 'builds nested params' do
+      inner_params = nil
       subject.get '/declared' do
-        declared(params)[:nested].keys.size.should == 1
+        inner_params = declared(params)
         ""
       end
 
       get '/declared?first=present&nested[fourth]=1'
       expect(last_response.status).to eq(200)
+      expect(inner_params[:nested].keys.size).to eq 1
     end
 
     it 'builds nested params when given array' do
@@ -254,33 +285,38 @@ describe Grape::Endpoint do
           optional :fourth
         end
       end
+      inner_params = nil
       subject.get '/declared' do
-        declared(params)[:nested].size.should == 2
+        inner_params = declared(params)
         ""
       end
 
       get '/declared?first=present&nested[][fourth]=1&nested[][fourth]=2'
       expect(last_response.status).to eq(200)
+      expect(inner_params[:nested].size).to eq 2
     end
 
     it 'filters out any additional params that are given' do
+      inner_params = nil
       subject.get '/declared' do
-        declared(params).key?(:other).should == false
+        inner_params = declared(params)
         ""
       end
-
       get '/declared?first=one&other=two'
       expect(last_response.status).to eq(200)
+      expect(inner_params.key?(:other)).to eq false
     end
 
     it 'stringifies if that option is passed' do
+      inner_params = nil
       subject.get '/declared' do
-        declared(params, stringify: true)["first"].should == "one"
+        inner_params = declared(params, stringify: true)
         ""
       end
 
       get '/declared?first=one&other=two'
       expect(last_response.status).to eq(200)
+      expect(inner_params["first"]).to eq "one"
     end
 
     it 'does not include missing attributes if that option is passed' do
@@ -586,6 +622,19 @@ describe Grape::Endpoint do
       expect(last_response.status).to eq(403)
       expect(last_response.headers['X-Custom']).to eq('value')
     end
+
+    it 'sets the status code for the endpoint' do
+      memoized_endpoint = nil
+
+      subject.get '/hey' do
+        memoized_endpoint = self
+        error!({ 'dude' => 'rad' }, 403, 'X-Custom' => 'value')
+      end
+
+      get '/hey.json'
+
+      expect(memoized_endpoint.status).to eq(403)
+    end
   end
 
   describe '#redirect' do

data/spec/grape/entity_spec.rb

@@ -10,17 +10,20 @@ describe Grape::Entity do
 
   describe '#present' do
     it 'sets the object as the body if no options are provided' do
+      inner_body = nil
       subject.get '/example' do
         present(abc: 'def')
-        body.should == { abc: 'def' }
+        inner_body = body
       end
       get '/example'
+      expect(inner_body).to eql(abc: 'def')
     end
 
     it 'calls through to the provided entity class if one is given' do
+      entity_mock = Object.new
+      allow(entity_mock).to receive(:represent)
+
       subject.get '/example' do
-        entity_mock = Object.new
-        entity_mock.should_receive(:represent)
         present Object.new, with: entity_mock
       end
       get '/example'
@@ -155,11 +158,13 @@ describe Grape::Entity do
     end
 
     it 'adds a root key to the output if one is given' do
+      inner_body = nil
       subject.get '/example' do
         present({ abc: 'def' }, root: :root)
-        body.should == { root: { abc: 'def' } }
+        inner_body = body
       end
       get '/example'
+      expect(inner_body).to eql(root: { abc: 'def' })
     end
 
     [:json, :serializable_hash].each do |format|

data/spec/grape/exceptions/validation_errors_spec.rb

@@ -3,7 +3,7 @@ require 'ostruct'
 
 describe Grape::Exceptions::ValidationErrors do
   let(:validation_message) { "FooBar is invalid" }
-  let(:validation_error) { OpenStruct.new(param: validation_message) }
+  let(:validation_error) { OpenStruct.new(params: [validation_message]) }
 
   context "message" do
     context "is not repeated" do
@@ -16,4 +16,34 @@ describe Grape::Exceptions::ValidationErrors do
       it { expect(message.size).to eq 1 }
     end
   end
+
+  context 'api' do
+    subject { Class.new(Grape::API) }
+
+    def app
+      subject
+    end
+
+    it 'can return structured json with separate fields' do
+      subject.format :json
+      subject.rescue_from Grape::Exceptions::ValidationErrors do |e|
+        rack_response e.to_json, 400
+      end
+      subject.params do
+        optional :beer
+        optional :wine
+        optional :juice
+        exactly_one_of :beer, :wine, :juice
+      end
+      subject.get '/exactly_one_of' do
+        'exactly_one_of works!'
+      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" => ["beer", "wine"],
+        "messages" => ["are mutually exclusive"]
+      ])
+    end
+  end
 end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'base64'
+
+describe Grape::Middleware::Auth::Base do
+  subject do
+    Class.new(Grape::API) do
+
+      http_basic realm: 'my_realm' do |user, password|
+        user && password && user == password
+      end
+      get '/authorized' do
+        'DONE'
+      end
+
+    end
+
+  end
+
+  def app
+    subject
+  end
+
+  it 'authenticates if given valid creds' do
+    get '/authorized', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'admin')
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq('DONE')
+  end
+
+  it 'throws a 401 is wrong auth is given' do
+    get '/authorized', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'wrong')
+    expect(last_response.status).to eq(401)
+  end
+
+end

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Grape::Middleware::Auth::DSL do
+  subject { Class.new(Grape::API) }
+
+  let(:block) { ->() {} }
+  let(:settings) do
+    {
+      opaque: "secret",
+      proc: block,
+      realm: "API Authorization",
+      type: :http_digest
+    }
+  end
+
+  describe '.auth' do
+    it 'stets auth parameters' do
+      expect(subject).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'))
+
+      subject.auth :http_digest, realm: settings[:realm], opaque: settings[:opaque], &settings[:proc]
+      first_settings = subject.auth
+
+      subject.auth :http_digest, realm: 'super_secret', opaque: settings[:opaque], &settings[:proc]
+
+      expect(subject.auth).to eq(settings.merge(realm: 'super_secret'))
+      expect(subject.auth.object_id).not_to eq(first_settings.object_id)
+    end
+
+  end
+
+  describe '.http_basic' do
+    it 'stets auth parameters' do
+      subject.http_basic realm: 'my_realm', &settings[:proc]
+      expect(subject.auth).to eq(realm: 'my_realm', type: :http_basic, proc: block)
+    end
+  end
+
+  describe '.http_digest' do
+    it 'stets auth parameters' do
+      subject.http_digest realm: 'my_realm', opaque: 'my_opaque', &settings[:proc]
+      expect(subject.auth).to eq(realm: 'my_realm', type: :http_digest, proc: block, opaque: 'my_opaque')
+    end
+  end
+
+end

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

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+require 'base64'
+
+describe Grape::Middleware::Auth::Strategies do
+  context 'Basic Auth' do
+    def app
+      proc = ->(u, p) { u && p && u == p }
+      Rack::Builder.new do |b|
+        b.use Grape::Middleware::Error
+        b.use(Grape::Middleware::Auth::Base, type: :http_basic, proc: proc)
+        b.run lambda { |env| [200, {}, ["Hello there."]] }
+      end
+    end
+
+    it 'throws a 401 if no auth is given' do
+      @proc = lambda { false }
+      get '/whatever'
+      expect(last_response.status).to eq(401)
+    end
+
+    it 'authenticates if given valid creds' do
+      get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'admin')
+      expect(last_response.status).to eq(200)
+    end
+
+    it 'throws a 401 is wrong auth is given' do
+      get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'wrong')
+      expect(last_response.status).to eq(401)
+    end
+  end
+
+  context 'Digest MD5 Auth' do
+    RSpec::Matchers.define :be_challenge do
+      match do |actual_response|
+        actual_response.status == 401 &&
+            actual_response['WWW-Authenticate'] =~ /^Digest / &&
+            actual_response.body.empty?
+      end
+    end
+
+    module StrategiesSpec
+      class Test < Grape::API
+        http_digest(realm: 'Test Api', opaque: 'secret') do |username|
+          { 'foo' => 'bar' }[username]
+        end
+
+        get '/test' do
+          [{ hey: 'you' }, { there: 'bar' }, { foo: 'baz' }]
+        end
+      end
+    end
+
+    def app
+      StrategiesSpec::Test
+    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

data/spec/grape/middleware/error_spec.rb

@@ -1,6 +1,17 @@
 require 'spec_helper'
+require 'grape-entity'
 
 describe Grape::Middleware::Error do
+  module ErrorSpec
+    class ErrorEntity < Grape::Entity
+      expose :code
+      expose :static
+
+      def static
+        'static text'
+      end
+    end
+  end
   class ErrApp
     class << self
       attr_accessor :error
@@ -13,12 +24,16 @@ describe Grape::Middleware::Error do
   end
 
   def app
+    opts = options
     Rack::Builder.app do
-      use Grape::Middleware::Error, default_message: 'Aww, hamburgers.'
+      use Spec::Support::EndpointFaker
+      use Grape::Middleware::Error, opts
       run ErrApp
     end
   end
 
+  let(:options) {  { default_message: 'Aww, hamburgers.' } }
+
   it 'sets the status code appropriately' do
     ErrApp.error = { status: 410 }
     get '/'
@@ -42,4 +57,21 @@ describe Grape::Middleware::Error do
     get '/'
     expect(last_response.body).to eq('Aww, hamburgers.')
   end
+
+  context 'with http code' do
+    let(:options) {  { default_message: 'Aww, hamburgers.' } }
+    it 'adds the status code if wanted' do
+      ErrApp.error = { message: { code: 200 } }
+      get '/'
+
+      expect(last_response.body).to eq({ code: 200 }.to_json)
+    end
+
+    it 'presents an error message' do
+      ErrApp.error = { message: { code: 200, with: ErrorSpec::ErrorEntity } }
+      get '/'
+
+      expect(last_response.body).to eq({ code: 200, static: 'static text' }.to_json)
+    end
+  end
 end