grape 0.3.0 → 0.7.0

data/spec/grape/entity_spec.rb

@@ -3,13 +3,16 @@ require 'grape_entity'
 
 describe Grape::Entity do
   subject { Class.new(Grape::API) }
-  def app; subject end
+
+  def app
+    subject
+  end
 
   describe '#present' do
     it 'sets the object as the body if no options are provided' do
       subject.get '/example' do
-        present({:abc => 'def'})
-        body.should == {:abc => 'def'}
+        present(abc: 'def')
+        body.should == { abc: 'def' }
       end
       get '/example'
     end
@@ -18,16 +21,16 @@ describe Grape::Entity do
       subject.get '/example' do
         entity_mock = Object.new
         entity_mock.should_receive(:represent)
-        present Object.new, :with => entity_mock
+        present Object.new, with: entity_mock
       end
       get '/example'
     end
 
     it 'pulls a representation from the class options if it exists' do
       entity = Class.new(Grape::Entity)
-      entity.stub!(:represent).and_return("Hiya")
+      entity.stub(:represent).and_return("Hiya")
 
-      subject.represent Object, :with => entity
+      subject.represent Object, with: entity
       subject.get '/example' do
         present Object.new
       end
@@ -37,25 +40,40 @@ describe Grape::Entity do
 
     it 'pulls a representation from the class options if the presented object is a collection of objects' do
       entity = Class.new(Grape::Entity)
-      entity.stub!(:represent).and_return("Hiya")
+      entity.stub(:represent).and_return("Hiya")
 
-      class TestObject; end
+      class TestObject
+      end
 
-      subject.represent TestObject, :with => entity
+      class FakeCollection
+        def first
+          TestObject.new
+        end
+      end
+
+      subject.represent TestObject, with: entity
       subject.get '/example' do
         present [TestObject.new]
       end
+
+      subject.get '/example2' do
+        present FakeCollection.new
+      end
+
       get '/example'
       last_response.body.should == "Hiya"
+
+      get '/example2'
+      last_response.body.should == "Hiya"
     end
 
     it 'pulls a representation from the class ancestor if it exists' do
       entity = Class.new(Grape::Entity)
-      entity.stub!(:represent).and_return("Hiya")
+      entity.stub(:represent).and_return("Hiya")
 
       subclass = Class.new(Object)
 
-      subject.represent Object, :with => entity
+      subject.represent Object, with: entity
       subject.get '/example' do
         present subclass.new
       end
@@ -66,7 +84,7 @@ describe Grape::Entity do
     it 'automatically uses Klass::Entity if that exists' do
       some_model = Class.new
       entity = Class.new(Grape::Entity)
-      entity.stub!(:represent).and_return("Auto-detect!")
+      entity.stub(:represent).and_return("Auto-detect!")
 
       some_model.const_set :Entity, entity
 
@@ -80,7 +98,7 @@ describe Grape::Entity do
     it 'automatically uses Klass::Entity based on the first object in the collection being presented' do
       some_model = Class.new
       entity = Class.new(Grape::Entity)
-      entity.stub!(:represent).and_return("Auto-detect!")
+      entity.stub(:represent).and_return("Auto-detect!")
 
       some_model.const_set :Entity, entity
 
@@ -91,15 +109,40 @@ describe Grape::Entity do
       last_response.body.should == 'Auto-detect!'
     end
 
+    it 'does not run autodetection for Entity when explicitely provided' do
+      entity = Class.new(Grape::Entity)
+      some_array = Array.new
+
+      subject.get '/example' do
+        present some_array, with: entity
+      end
+
+      some_array.should_not_receive(:first)
+      get '/example'
+    end
+
+    it 'autodetection does not use Entity if it is not a presenter' do
+      some_model = Class.new
+      entity = Class.new
+
+      some_model.class.const_set :Entity, entity
+
+      subject.get '/example' do
+        present some_model
+      end
+      get '/example'
+      entity.should_not_receive(:represent)
+    end
+
     it 'adds a root key to the output if one is given' do
       subject.get '/example' do
-        present({:abc => 'def'}, :root => :root)
-        body.should == {:root => {:abc => 'def'}}
+        present({ abc: 'def' }, root: :root)
+        body.should == { root: { abc: 'def' } }
       end
       get '/example'
     end
 
-    [ :json, :serializable_hash ].each do |format|
+    [:json, :serializable_hash].each do |format|
 
       it 'presents with #{format}' do
         entity = Class.new(Grape::Entity)
@@ -114,7 +157,7 @@ describe Grape::Entity do
               @id = id
             end
           end
-          present c.new(1), :with => entity
+          present c.new(1), with: entity
         end
 
         get '/example'
@@ -135,8 +178,8 @@ describe Grape::Entity do
               @id = id
             end
           end
-          examples = [ c.new(1), c.new(2) ]
-          present examples, :with => entity
+          examples = [c.new(1), c.new(2)]
+          present examples, with: entity
         end
 
         get '/examples'
@@ -146,21 +189,21 @@ describe Grape::Entity do
 
     end
 
-    it 'presents with xml' do 
+    it 'presents with xml' do
       entity = Class.new(Grape::Entity)
       entity.root "examples", "example"
       entity.expose :name
 
       subject.format :xml
 
-      subject.get '/example' do 
-        c = Class.new do 
+      subject.get '/example' do
+        c = Class.new do
           attr_reader :name
           def initialize(args)
             @name = args[:name] || "no name set"
           end
         end
-        present c.new({:name => "johnnyiller"}), :with => entity
+        present c.new(name: "johnnyiller"), with: entity
       end
       get '/example'
       last_response.status.should == 200
@@ -175,27 +218,87 @@ describe Grape::Entity do
 XML
     end
 
-    it 'presents with json' do 
+    it 'presents with json' do
       entity = Class.new(Grape::Entity)
       entity.root "examples", "example"
       entity.expose :name
 
       subject.format :json
 
-      subject.get '/example' do 
-        c = Class.new do 
+      subject.get '/example' do
+        c = Class.new do
           attr_reader :name
           def initialize(args)
             @name = args[:name] || "no name set"
           end
         end
-        present c.new({:name => "johnnyiller"}), :with => entity
+        present c.new(name: "johnnyiller"), with: entity
       end
       get '/example'
       last_response.status.should == 200
       last_response.headers['Content-type'].should == "application/json"
       last_response.body.should == '{"example":{"name":"johnnyiller"}}'
     end
-  end
 
-end
+    it 'presents with jsonp utilising Rack::JSONP' do
+      require 'rack/contrib'
+
+      # Include JSONP middleware
+      subject.use Rack::JSONP
+
+      entity = Class.new(Grape::Entity)
+      entity.root "examples", "example"
+      entity.expose :name
+
+      # Rack::JSONP expects a standard JSON response
+      subject.format :json
+
+      subject.get '/example' do
+        c = Class.new do
+          attr_reader :name
+          def initialize(args)
+            @name = args[:name] || "no name set"
+          end
+        end
+
+        present c.new(name: "johnnyiller"), with: entity
+      end
+
+      get '/example?callback=abcDef'
+      last_response.status.should == 200
+      last_response.headers['Content-type'].should == "application/javascript"
+      last_response.body.should == 'abcDef({"example":{"name":"johnnyiller"}})'
+    end
+
+    context "present with multiple entities" do
+      it "present with multiple entities using optional symbol" do
+        user = Class.new do
+          attr_reader :name
+          def initialize(args)
+            @name = args[:name] || "no name set"
+          end
+        end
+        user1 = user.new(name: 'user1')
+        user2 = user.new(name: 'user2')
+
+        entity = Class.new(Grape::Entity)
+        entity.expose :name
+
+        subject.format :json
+        subject.get '/example' do
+          present :page, 1
+          present :user1, user1, with: entity
+          present :user2, user2, with: entity
+        end
+        get '/example'
+        expect_response_json = {
+          "page"  => 1,
+          "user1" => { "name" => "user1" },
+          "user2" => { "name" => "user2" }
+        }
+        JSON(last_response.body).should == expect_response_json
+      end
+
+    end
+  end
+end

data/spec/grape/exceptions/missing_mime_type_spec.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
 require 'spec_helper'
+
 describe Grape::Exceptions::MissingMimeType do
   describe "#message" do
 
@@ -8,17 +8,11 @@ describe Grape::Exceptions::MissingMimeType do
     end
 
     it "contains the problem in the message" do
-      error.message.should include(
-        "missing mime type for new_json"
-      )
+      error.message.should include "missing mime type for new_json"
     end
 
     it "contains the resolution in the message" do
-      error.message.should include(
-        "or add your own with content_type :new_json, 'application/new_json' "
-      )
+      error.message.should include "or add your own with content_type :new_json, 'application/new_json' "
     end
   end
-
-
 end

data/spec/grape/exceptions/validation_errors_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Grape::Exceptions::ValidationErrors do
+  let(:validation_message) { "FooBar is invalid" }
+  let(:validation_error) { OpenStruct.new(param: validation_message) }
+
+  context "message" do
+    context "is not repeated" do
+      let(:error) do
+        described_class.new(errors: [validation_error, validation_error])
+      end
+      subject(:message) { error.message.split(',').map(&:strip) }
+
+      it { expect(message).to include validation_message }
+      it { expect(message.size).to eq 1 }
+    end
+  end
+end

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

@@ -6,26 +6,26 @@ describe Grape::Middleware::Auth::Basic do
   def app
     Rack::Builder.new do |b|
       b.use Grape::Middleware::Error
-      b.use(Grape::Middleware::Auth::Basic) do |u,p| 
+      b.use(Grape::Middleware::Auth::Basic) do |u, p|
         u && p && u == p
       end
-      b.run lambda{|env| [200, {}, ["Hello there."]]}
+      b.run lambda { |env| [200, {}, ["Hello there."]] }
     end
   end
-  
+
   it 'throws a 401 if no auth is given' do
-    @proc = lambda{ false }
+    @proc = lambda { false }
     get '/whatever'
     last_response.status.should == 401
   end
-  
+
   it 'authenticates if given valid creds' do
-    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin','admin')
+    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'admin')
     last_response.status.should == 200
   end
-  
+
   it 'throws a 401 is wrong auth is given' do
-    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin','wrong')
+    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'wrong')
     last_response.status.should == 401
   end
 end

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

@@ -9,12 +9,12 @@ RSpec::Matchers.define :be_challenge do
 end
 
 class Test < Grape::API
-  http_digest({:realm => 'Test Api', :opaque => 'secret'}) do |username|
-    {'foo' => 'bar'}[username]
+  http_digest(realm: 'Test Api', opaque: 'secret') do |username|
+    { 'foo' => 'bar' }[username]
   end
 
   get '/test' do
-    [{:hey => 'you'},{:there => 'bar'},{:foo => 'baz'}]
+    [{ hey: 'you' }, { there: 'bar' }, { foo: 'baz' }]
   end
 end
 
@@ -22,12 +22,12 @@ describe Grape::Middleware::Auth::Digest do
   def app
     Test
   end
-  
+
   it 'is a digest authentication challenge' do
     get '/test'
     last_response.should be_challenge
   end
-  
+
   it 'throws a 401 if no auth is given' do
     get '/test'
     last_response.status.should == 401

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

@@ -2,89 +2,134 @@ require 'spec_helper'
 
 describe Grape::Middleware::Auth::OAuth2 do
   class FakeToken
+    attr_accessor :token
+
     def self.verify(token)
-      FakeToken.new(token) if %w(g e).include?(token[0..0])
+      FakeToken.new(token) if !!token && %w(g e).include?(token[0..0])
     end
-    
+
     def initialize(token)
-      self.token = token
+      @token = token
     end
-    
+
     def expired?
-      self.token[0..0] == 'e'
+      @token[0..0] == 'e'
     end
-    
+
     def permission_for?(env)
       env['PATH_INFO'] == '/forbidden' ? false : true
     end
-    
-    attr_accessor :token
   end
 
   def app
     Rack::Builder.app do
-      use Grape::Middleware::Auth::OAuth2, :token_class => 'FakeToken'
-      run lambda{|env| [200, {}, [ (env['api.token'].token rescue '') ]]}
+      use Grape::Middleware::Auth::OAuth2, token_class: 'FakeToken'
+      run lambda { |env| [200, {}, [(env['api.token'].token if env['api.token'])]] }
     end
   end
-  
+
   context 'with the token in the query string' do
     context 'and a valid token' do
-      before { get '/awesome?oauth_token=g123' }
-      
+      before { get '/awesome?access_token=g123' }
+
       it 'sets env["api.token"]' do
         last_response.body.should == 'g123'
       end
     end
-    
+
     context 'and an invalid token' do
       before do
         @err = catch :error do
-          get '/awesome?oauth_token=b123'
+          get '/awesome?access_token=b123'
         end
       end
-      
+
       it 'throws an error' do
         @err[:status].should == 401
       end
-      
+
       it 'sets the WWW-Authenticate header in the response' do
-        @err[:headers]['WWW-Authenticate'].should == "OAuth realm='OAuth API', error='invalid_token'"
+        @err[:headers]['WWW-Authenticate'].should == "OAuth realm='OAuth API', error='invalid_grant'"
       end
     end
   end
-  
+
   context 'with an expired token' do
     before do
       @err = catch :error do
-        get '/awesome?oauth_token=e123'
+        get '/awesome?access_token=e123'
       end
     end
-    
-    it { @err[:status].should == 401 }
-    it { @err[:headers]['WWW-Authenticate'].should == "OAuth realm='OAuth API', error='expired_token'" }
+
+    it 'throws an error' do
+      @err[:status].should == 401
+    end
+
+    it 'sets the WWW-Authenticate header in the response to error' do
+      @err[:headers]['WWW-Authenticate'].should == "OAuth realm='OAuth API', error='invalid_grant'"
+    end
   end
-  
-  %w(HTTP_AUTHORIZATION X_HTTP_AUTHORIZATION X-HTTP_AUTHORIZATION REDIRECT_X_HTTP_AUTHORIZATION).each do |head|  
-    context 'with the token in the #{head} header' do
-      before { get '/awesome', {}, head => 'OAuth g123' }
-      it { last_response.body.should == 'g123' }
+
+  %w(HTTP_AUTHORIZATION X_HTTP_AUTHORIZATION X-HTTP_AUTHORIZATION REDIRECT_X_HTTP_AUTHORIZATION).each do |head|
+    context "with the token in the #{head} header" do
+      before do
+        get '/awesome', {}, head => 'OAuth g123'
+      end
+
+      it 'sets env["api.token"]' do
+        last_response.body.should == 'g123'
+      end
     end
   end
-  
+
   context 'with the token in the POST body' do
-    before { post '/awesome', {'oauth_token' => 'g123'} }
-    it { last_response.body.should == 'g123'}
+    before do
+      post '/awesome', 'access_token' => 'g123'
+    end
+
+    it 'sets env["api.token"]' do
+      last_response.body.should == 'g123'
+    end
   end
-  
+
   context 'when accessing something outside its scope' do
     before do
       @err = catch :error do
-        get '/forbidden?oauth_token=g123'
+        get '/forbidden?access_token=g123'
+      end
+    end
+
+    it 'throws an error' do
+      @err[:status].should == 403
+    end
+
+    it 'sets the WWW-Authenticate header in the response to error' do
+      @err[:headers]['WWW-Authenticate'].should == "OAuth realm='OAuth API', error='insufficient_scope'"
+    end
+  end
+
+  context 'when authorization is not required' do
+    def app
+      Rack::Builder.app do
+        use Grape::Middleware::Auth::OAuth2, token_class: 'FakeToken', required: false
+        run lambda { |env| [200, {}, [(env['api.token'].token if env['api.token'])]] }
+      end
+    end
+
+    context 'with no token' do
+      before { post '/awesome' }
+
+      it 'succeeds anyway' do
+        last_response.status.should == 200
+      end
+    end
+
+    context 'with a valid token' do
+      before { get '/awesome?access_token=g123' }
+
+      it 'sets env["api.token"]' do
+        last_response.body.should == 'g123'
       end
     end
-    
-    it { @err[:headers]['WWW-Authenticate'].should == "OAuth realm='OAuth API', error='insufficient_scope'" }
-    it { @err[:status].should == 403 }
   end
 end

data/spec/grape/middleware/base_spec.rb

@@ -1,23 +1,18 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Base do
-  subject { Grape::Middleware::Base.new(  blank_app) }
-  let(:blank_app) { lambda{|_| [200, {}, 'Hi there.']} }
+  subject { Grape::Middleware::Base.new(blank_app) }
+  let(:blank_app) { lambda { |_| [200, {}, 'Hi there.'] } }
 
   before do
     # Keep it one object for testing.
-    subject.stub!(:dup).and_return(subject)
+    subject.stub(:dup).and_return(subject)
   end
 
   it 'has the app as an accessor' do
     subject.app.should == blank_app
   end
 
-  it 'is able to access the request' do
-    subject.call({})
-    subject.request.should be_kind_of(Rack::Request)
-  end
-
   it 'calls through to the app' do
     subject.call({}).should == [200, {}, 'Hi there.']
   end
@@ -31,7 +26,7 @@ describe Grape::Middleware::Base do
       subject.should_receive(:after)
     end
 
-    after{ subject.call!({}) }
+    after { subject.call!({}) }
   end
 
   it 'is able to access the response' do
@@ -41,22 +36,22 @@ describe Grape::Middleware::Base do
 
   context 'options' do
     it 'persists options passed at initialization' do
-      Grape::Middleware::Base.new(blank_app, {:abc => true}).options[:abc].should be_true
+      Grape::Middleware::Base.new(blank_app, abc: true).options[:abc].should be true
     end
 
     context 'defaults' do
       class ExampleWare < Grape::Middleware::Base
         def default_options
-          {:monkey => true}
+          { monkey: true }
         end
       end
 
       it 'persists the default options' do
-        ExampleWare.new(blank_app).options[:monkey].should be_true
+        ExampleWare.new(blank_app).options[:monkey].should be true
       end
 
       it 'overrides default options when provided' do
-        ExampleWare.new(blank_app, :monkey => false).options[:monkey].should be_false
+        ExampleWare.new(blank_app, monkey: false).options[:monkey].should be false
       end
     end
   end