grape 0.2.1.1 → 0.2.2

data/spec/grape/endpoint_spec.rb

@@ -108,6 +108,57 @@ describe Grape::Endpoint do
     end
   end
 
+  describe '#declared' do
+    before do
+      subject.params do
+        requires :first
+        optional :second
+      end
+
+
+    end
+
+    it 'should have as many keys as there are declared params' do
+      subject.get "/declared" do
+        declared(params).keys.size.should == 2
+        ""
+      end
+
+      get '/declared?first=present'
+      last_response.status.should == 200
+    end
+
+    it 'should filter out any additional params that are given' do
+      subject.get "/declared" do
+        declared(params).key?(:other).should == false
+        ""
+      end
+
+      get '/declared?first=one&other=two'
+      last_response.status.should == 200
+    end
+
+    it 'should stringify if that option is passed' do
+      subject.get "/declared" do
+        declared(params, :stringify => true)["first"].should == "one"
+        ""
+      end
+
+      get '/declared?first=one&other=two'
+      last_response.status.should == 200
+    end
+
+    it 'should not include missing attributes if that option is passed' do
+      subject.get "/declared" do
+        declared(params, :include_missing => false)[:second].should == nil
+        ""
+      end
+
+      get '/declared?first=one&other=two'
+      last_response.status.should == 200
+    end
+  end
+
   describe '#params' do
     it 'should be available to the caller' do
       subject.get('/hey') do
@@ -186,9 +237,9 @@ describe Grape::Endpoint do
         last_response.body.should == 'Bobby T.'
       end
 
-      it 'should convert JSON bodies to params' do
-        put '/request_body', MultiJson.encode(:user => 'Bobby T.'), {'CONTENT_TYPE' => 'application/json'}
-        last_response.body.should == 'Bobby T.'
+      it 'should not convert empty JSON bodies to params' do
+        put '/request_body', '', {'CONTENT_TYPE' => 'application/json'}
+        last_response.body.should == ''
       end
 
       it 'should convert XML bodies to params' do
@@ -268,7 +319,7 @@ describe Grape::Endpoint do
         redirect "/ha", :permanent => true
       end
       get '/hey'
-      last_response.status.should eq 304
+      last_response.status.should eq 301
       last_response.headers['Location'].should eq "/ha"
       last_response.body.should eq ""
     end
@@ -347,6 +398,20 @@ describe Grape::Endpoint do
       last_response.body.should == 'Hiya'
     end
 
+    it 'should automatically use Klass::Entity if that exists' do
+      some_model = Class.new
+      entity = Class.new(Grape::Entity)
+      entity.stub!(:represent).and_return("Auto-detect!")
+
+      some_model.const_set :Entity, entity
+
+      subject.get '/example' do
+        present some_model.new
+      end
+      get '/example'
+      last_response.body.should == 'Auto-detect!'
+    end
+
     it 'should add a root key to the output if one is given' do
       subject.get '/example' do
         present({:abc => 'def'}, :root => :root)

data/spec/grape/entity_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe Grape::Entity do
-  let(:fresh_class){ Class.new(Grape::Entity) }
+  let(:fresh_class) { Class.new(Grape::Entity) }
 
   context 'class methods' do
-    subject{ fresh_class }
+    subject { fresh_class }
 
     describe '.expose' do
       context 'multiple attributes' do
@@ -235,20 +235,24 @@ describe Grape::Entity do
   end
 
   context 'instance methods' do
+    
     let(:model){ mock(attributes) }
-    let(:attributes){ {
-      :name => 'Bob Bobson', 
+    
+    let(:attributes) { {
+      :name => 'Bob Bobson',
       :email => 'bob@example.com',
       :birthday => Time.gm(2012, 2, 27),
       :fantasies => ['Unicorns', 'Double Rainbows', 'Nessy'],
       :friends => [
-        mock(:name => "Friend 1", :email => 'friend1@example.com', :fantasies => [], :birthday => Time.gm(2012, 2, 27), :friends => []), 
+        mock(:name => "Friend 1", :email => 'friend1@example.com', :fantasies => [], :birthday => Time.gm(2012, 2, 27), :friends => []),
         mock(:name => "Friend 2", :email => 'friend2@example.com', :fantasies => [], :birthday => Time.gm(2012, 2, 27), :friends => [])
       ]
     } }
+    
     subject{ fresh_class.new(model) }
 
     describe '#serializable_hash' do
+
       it 'should not throw an exception if a nil options object is passed' do
         expect{ fresh_class.new(model).serializable_hash(nil) }.not_to raise_error
       end
@@ -257,6 +261,88 @@ describe Grape::Entity do
         fresh_class.expose :name
         expect{ fresh_class.new(nil).serializable_hash }.not_to raise_error
       end
+
+      it 'should not throw an exception when an attribute is not found on the object' do
+        fresh_class.expose :name, :non_existant_attribute
+        expect{ fresh_class.new(model).serializable_hash }.not_to raise_error
+      end
+
+      it "should not expose attributes that don't exist on the object" do
+        fresh_class.expose :email, :non_existant_attribute, :name
+
+        res = fresh_class.new(model).serializable_hash
+        res.should have_key :email
+        res.should_not have_key :non_existant_attribute
+        res.should have_key :name
+      end
+
+      it "should not expose attributes that don't exist on the object, even with criteria" do
+        fresh_class.expose :email
+        fresh_class.expose :non_existant_attribute, :if => lambda { false }
+        fresh_class.expose :non_existant_attribute2, :if => lambda { true }
+
+        res = fresh_class.new(model).serializable_hash
+        res.should have_key :email
+        res.should_not have_key :non_existant_attribute
+        res.should_not have_key :non_existant_attribute2
+      end
+
+      it "should expose attributes that don't exist on the object only when they are generated by a block" do
+        fresh_class.expose :non_existant_attribute do |model, options|
+          "well, I do exist after all"
+        end
+        res = fresh_class.new(model).serializable_hash
+        res.should have_key :non_existant_attribute
+      end
+
+      it "should not expose attributes that are generated by a block but have not passed criteria" do
+        fresh_class.expose :non_existant_attribute, :proc => lambda {|model, options|
+          "I exist, but it is not yet my time to shine"
+        }, :if => lambda { |model, options| false }
+        res = fresh_class.new(model).serializable_hash
+        res.should_not have_key :non_existant_attribute
+      end
+      
+      context "#serializable_hash" do
+      
+        module EntitySpec
+          class EmbeddedExample
+            def serializable_hash(opts = {})
+              { :abc => 'def' }
+            end
+          end
+          class EmbeddedExampleWithMany
+            def name
+              "abc"
+            end
+            def embedded
+              [ EmbeddedExample.new, EmbeddedExample.new ]
+            end
+          end
+          class EmbeddedExampleWithOne
+            def name
+              "abc"
+            end
+            def embedded
+              EmbeddedExample.new
+            end
+          end
+        end
+      
+        it 'should serialize embedded objects which respond to #serializable_hash' do
+          fresh_class.expose :name, :embedded
+          presenter = fresh_class.new(EntitySpec::EmbeddedExampleWithOne.new)
+          presenter.serializable_hash.should == {:name => "abc", :embedded => {:abc => "def"}}
+        end
+
+        it 'should serialize embedded arrays of objects which respond to #serializable_hash' do
+          fresh_class.expose :name, :embedded
+          presenter = fresh_class.new(EntitySpec::EmbeddedExampleWithMany.new)
+          presenter.serializable_hash.should == {:name => "abc", :embedded => [{:abc => "def"}, {:abc => "def"}]}
+        end
+        
+      end
+      
     end
 
     describe '#value_for' do
@@ -289,19 +375,73 @@ describe Grape::Entity do
         rep.last.serializable_hash[:name].should == 'Friend 2'
       end
 
-      it 'should disable root key name for child representations' do
-        class FriendEntity < Grape::Entity
-          root 'friends', 'friend'
-          expose :name, :email
+      context 'child representations' do
+        it 'should disable root key name for child representations' do
+        
+          module EntitySpec
+            class FriendEntity < Grape::Entity
+              root 'friends', 'friend'
+              expose :name, :email
+            end
+          end
+          
+          fresh_class.class_eval do
+            expose :friends, :using => EntitySpec::FriendEntity
+          end
+          
+          rep = subject.send(:value_for, :friends)
+          rep.should be_kind_of(Array)
+          rep.reject{|r| r.is_a?(EntitySpec::FriendEntity)}.should be_empty
+          rep.first.serializable_hash[:name].should == 'Friend 1'
+          rep.last.serializable_hash[:name].should == 'Friend 2'
         end
-        fresh_class.class_eval do
-          expose :friends, :using => FriendEntity
+
+        it 'should pass through custom options' do
+          module EntitySpec
+            class FriendEntity < Grape::Entity
+              root 'friends', 'friend'
+              expose :name
+              expose :email, :if => { :user_type => :admin }
+            end
+          end
+          
+          fresh_class.class_eval do
+            expose :friends, :using => EntitySpec::FriendEntity
+          end
+          
+          rep = subject.send(:value_for, :friends)
+          rep.should be_kind_of(Array)
+          rep.reject{|r| r.is_a?(EntitySpec::FriendEntity)}.should be_empty
+          rep.first.serializable_hash[:email].should be_nil
+          rep.last.serializable_hash[:email].should be_nil
+
+          rep = subject.send(:value_for, :friends, { :user_type => :admin })
+          rep.should be_kind_of(Array)
+          rep.reject{|r| r.is_a?(EntitySpec::FriendEntity)}.should be_empty
+          rep.first.serializable_hash[:email].should == 'friend1@example.com'
+          rep.last.serializable_hash[:email].should == 'friend2@example.com'
         end
-        rep = subject.send(:value_for, :friends)
-        rep.should be_kind_of(Array)
-        rep.reject{|r| r.is_a?(FriendEntity)}.should be_empty
-        rep.first.serializable_hash[:name].should == 'Friend 1'
-        rep.last.serializable_hash[:name].should == 'Friend 2'
+
+        it 'should ignore the :collection parameter in the source options' do
+          module EntitySpec
+            class FriendEntity < Grape::Entity
+              root 'friends', 'friend'
+              expose :name
+              expose :email, :if => { :collection => true }
+            end
+          end
+          
+          fresh_class.class_eval do
+            expose :friends, :using => EntitySpec::FriendEntity
+          end
+          
+          rep = subject.send(:value_for, :friends, { :collection => false })
+          rep.should be_kind_of(Array)
+          rep.reject{|r| r.is_a?(EntitySpec::FriendEntity)}.should be_empty
+          rep.first.serializable_hash[:email].should == 'friend1@example.com'
+          rep.last.serializable_hash[:email].should == 'friend2@example.com'
+        end
+
       end
 
       it 'should call through to the proc if there is one' do
@@ -387,5 +527,53 @@ describe Grape::Entity do
         subject.send(:conditions_met?, exposure_options, :true => true).should be_false
       end
     end
+
+    describe "::DSL" do
+      subject{ Class.new }
+
+      it 'should create an Entity class when called' do
+        subject.should_not be_const_defined(:Entity)
+        subject.send(:include, Grape::Entity::DSL)
+        subject.should be_const_defined(:Entity)
+      end
+
+      context 'pre-mixed' do
+        before{ subject.send(:include, Grape::Entity::DSL) }
+
+        it 'should be able to define entity traits through DSL' do
+          subject.entity do
+            expose :name
+          end
+
+          subject.entity_class.exposures.should_not be_empty
+        end
+
+        it 'should be able to expose straight from the class' do
+          subject.entity :name, :email
+          subject.entity_class.exposures.size.should == 2
+        end
+
+        it 'should be able to mix field and advanced exposures' do
+          subject.entity :name, :email do
+            expose :third
+          end
+          subject.entity_class.exposures.size.should == 3
+        end
+
+        context 'instance' do
+          let(:instance){ subject.new }
+
+          describe '#entity' do
+            it 'should be an instance of the entity class' do
+              instance.entity.should be_kind_of(subject.entity_class)
+            end
+
+            it 'should have an object of itself' do
+              instance.entity.object.should == instance
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/grape/middleware/exception_spec.rb

@@ -34,6 +34,16 @@ describe Grape::Middleware::Error do
       end
     end
   end
+
+  # raises a custom error
+  class CustomError < Grape::Exceptions::Base; end
+  class CustomErrorApp
+    class << self
+      def call(env)
+        raise CustomError, :status => 400, :message => 'failed validation'
+      end
+    end
+  end
   
   def app
     @app
@@ -116,6 +126,17 @@ describe Grape::Middleware::Error do
       get '/'
       last_response.status.should == 401    
     end 
+
+    it 'should respond to custom Grape exceptions appropriately' do
+      @app ||= Rack::Builder.app do
+        use Grape::Middleware::Error, :rescue_all => false
+        run CustomErrorApp
+      end
+
+      get '/'
+      last_response.status.should == 400
+      last_response.body.should == 'failed validation'
+    end
     
   end 
 end

data/spec/grape/middleware/formatter_spec.rb

@@ -48,6 +48,18 @@ describe Grape::Middleware::Formatter do
       subject.call({'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json'}).last.each{|b| b.should == '{"abc":"def"}'}
     end
 
+    it 'should serialize objects that respond to #serializable_hash if there is a root element' do
+      class SimpleExample
+        def serializable_hash
+          {:abc => 'def'}
+        end
+      end
+
+      @body = {"root" => SimpleExample.new}
+
+      subject.call({'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json'}).last.each{|b| b.should == '{"root":{"abc":"def"}}'}
+    end
+
     it 'should call #to_xml if the content type is xml' do
       @body = "string"
       @body.instance_eval do
@@ -68,6 +80,13 @@ describe Grape::Middleware::Formatter do
       subject.env['api.format'].should == :json
     end
 
+    it 'should use the format parameter if one is provided' do 
+      subject.call({'PATH_INFO' => '/somewhere','QUERY_STRING' => 'format=json'})
+      subject.env['api.format'].should == :json
+      subject.call({'PATH_INFO' => '/somewhere','QUERY_STRING' => 'format=xml'})
+      subject.env['api.format'].should == :xml
+    end
+
     it 'should use the default format if none is provided' do
       subject.call({'PATH_INFO' => '/info'})
       subject.env['api.format'].should == :txt

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

@@ -2,147 +2,218 @@ require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Header do
   let(:app) { lambda{|env| [200, env, env]} }
-  let(:accept) { 'application/vnd.vendor-v1+json' }
   subject { Grape::Middleware::Versioner::Header.new(app, @options || {}) }
 
+  before do
+    @options = {
+      :version_options => {
+        :using => :header,
+        :vendor => 'vendor',
+      },
+    }
+  end
+
   context 'api.type and api.subtype' do
-    it 'should set any type and any subtype' do
-      env = subject.call('HTTP_ACCEPT' => '*/*').last
-      env['api.type'].should eql '*'
-      env['api.subtype'].should eql '*'
+    it 'should set type and subtype to first choice of content type if no preference given' do
+      status, _, env = subject.call('HTTP_ACCEPT' => '*/*')
+      env['api.type'].should eql 'application'
+      env['api.subtype'].should eql 'vnd.vendor+xml'
+      status.should == 200
+    end
+
+    it 'should set preferred type' do
+      status, _, env = subject.call('HTTP_ACCEPT' => 'application/*')
+      env['api.type'].should eql 'application'
+      env['api.subtype'].should eql 'vnd.vendor+xml'
+      status.should == 200
     end
 
     it 'should set preferred type and subtype' do
-      env = subject.call('HTTP_ACCEPT' => 'text/html').last
+      status, _, env = subject.call('HTTP_ACCEPT' => 'text/plain')
       env['api.type'].should eql 'text'
-      env['api.subtype'].should eql 'html'
+      env['api.subtype'].should eql 'plain'
+      status.should == 200
     end
   end
 
   context 'api.format' do
     it 'should be set' do
-      env = subject.call('HTTP_ACCEPT' => accept).last
+      status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor+json')
       env['api.format'].should eql 'json'
+      status.should == 200
     end
 
     it 'should be nil if not provided' do
-      env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1').last
+      status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor')
       env['api.format'].should eql nil
+      status.should == 200
+    end
+
+    context 'when version is set' do
+      before do
+        @options[:versions] = ['v1']
+      end
+
+      it 'should be set' do
+        status, _, env =  subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json')
+        env['api.format'].should eql 'json'
+        status.should == 200
+      end
+
+      it 'should be nil if not provided' do
+        status, _, env =  subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1')
+        env['api.format'].should eql nil
+        status.should == 200
+      end
     end
   end
 
-  context 'matched version' do
-    before do
-      @options = {
-        :versions => ['v1'],
-        :version_options => {:using => :header}
-      }
+  context 'api.vendor' do
+    it 'should be set' do
+      status, _, env =  subject.call('HTTP_ACCEPT' => 'application/vnd.vendor')
+      env['api.vendor'].should eql 'vendor'
+      status.should == 200
     end
 
-    it 'should set api.vendor' do
-      env = subject.call('HTTP_ACCEPT' => accept).last
+    it 'should be set if format provided' do
+      status, _, env =  subject.call('HTTP_ACCEPT' => 'application/vnd.vendor+json')
       env['api.vendor'].should eql 'vendor'
+      status.should == 200
     end
 
-    it 'should set api.version' do
-      env = subject.call('HTTP_ACCEPT' => accept).last
-      env['api.version'].should eql 'v1'
+    it 'should fail with 406 Not Acceptable if vendor is invalid' do
+      expect {
+        env = subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor+json').last
+      }.to throw_symbol(
+        :error,
+        :status => 406,
+        :headers => {'X-Cascade' => 'pass'},
+        :message => 'API vendor or version not found'
+      )
     end
-  end
 
-  context 'no header' do
-    it 'should return a 200 when no header is set and no strict setting is done' do
-      @options = {
-        :versions => ['v1'],
-        :version_options => {:using => :header}
-      }
-      subject.call('HTTP_ACCEPT' => '').first.should == 200
-      subject.call({}).first.should == 200
-    end
-
-    it 'should return a 200 when no header is set but strict header based versioning is disabled' do
-      @options = {
-        :versions => ['v1'],
-        :version_options => {:using => :header, :strict => false}
-      }
-      subject.call('HTTP_ACCEPT' => '').first.should == 200
-      subject.call({}).first.should == 200
-    end
-
-    context 'when strict header versioning is used' do
-      it 'should return a 406 when no header' do
-        @options = {
-          :versions => ['v1'],
-          :version_options => {:using => :header, :strict => true}
-        }
-        expect {
-          env = subject.call('HTTP_ACCEPT' => '').last
-        }.to throw_symbol(
-          :error,
-          :status => 406,
-          :headers => {'X-Cascade' => 'pass'},
-          :message => "406 API Version Not Found"
-        )
+    context 'when version is set' do
+      before do
+        @options[:versions] = ['v1']
+      end
+
+      it 'should be set' do
+        status, _, env =  subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1')
+        env['api.vendor'].should eql 'vendor'
+        status.should == 200
+      end
+
+      it 'should be set if format provided' do
+        status, _, env =  subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json')
+        env['api.vendor'].should eql 'vendor'
+        status.should == 200
       end
 
-      it 'should return a 406 when incorrect header format is used' do
-        @options = {
-          :versions => ['v1'],
-          :version_options => {:using => :header, :strict => true}
-        }
+      it 'should fail with 406 Not Acceptable if vendor is invalid' do
         expect {
-          env = subject.call('HTTP_ACCEPT' => '*/*').last
+          env = subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor-v1+json').last
         }.to throw_symbol(
           :error,
           :status => 406,
           :headers => {'X-Cascade' => 'pass'},
-          :message => "406 API Version Not Found"
+          :message => 'API vendor or version not found'
         )
       end
-
-      it 'should return a 200 when proper header is set' do
-        @options = {
-          :versions => ['v1'],
-          :version_options => {:using => :header, :strict => true}
-        }
-        subject.call('HTTP_ACCEPT' => 'application/vnd.testing-v1+json').first.should == 200
-      end
     end
-
   end
 
-  context 'vendors' do
+  context 'api.version' do
     before do
-      @options = {
-        :version => ['v1'],
-        :version_options => {:using => :header, :vendor => 'vendor'}
-      }
+      @options[:versions] = ['v1']
     end
 
-    it 'should match with correct vendor' do
-      status = subject.call('HTTP_ACCEPT' => accept).first
+    it 'should be set' do
+      status, _, env =  subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1')
+      env['api.version'].should eql 'v1'
       status.should == 200
     end
 
-    it 'should not match with an incorrect vendor' do
+    it 'should be set if format provided' do
+      status, _, env =  subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json')
+      env['api.version'].should eql 'v1'
+      status.should == 200
+    end
+
+    it 'should fail with 406 Not Acceptable if version is invalid' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor-v1+json').last
-      }.to throw_symbol(:error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found")
+        env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v2+json').last
+      }.to throw_symbol(
+        :error,
+        :status => 406,
+        :headers => {'X-Cascade' => 'pass'},
+        :message => 'API vendor or version not found'
+      )
     end
   end
 
-  context 'no matched version' do
+  it 'should succeed if :strict is not set' do
+    subject.call('HTTP_ACCEPT' => '').first.should == 200
+    subject.call({}).first.should == 200
+  end
+
+  it 'should succeed if :strict is set to false' do
+    @options[:version_options][:strict] = false
+    subject.call('HTTP_ACCEPT' => '').first.should == 200
+    subject.call({}).first.should == 200
+  end
+
+  context 'when :strict is set' do
     before do
-      @options = {
-        :versions => ['unknown_version'],
-        :version_options => {:using => :header}
-      }
+      @options[:versions] = ['v1']
+      @options[:version_options][:strict] = true
+    end
+
+    it 'should fail with 406 Not Acceptable if header is not set' do
+      expect {
+        env = subject.call({}).last
+      }.to throw_symbol(
+        :error,
+        :status => 406,
+        :headers => {'X-Cascade' => 'pass'},
+        :message => 'Accept header must be set'
+      )
+    end
+
+    it 'should fail with 406 Not Acceptable if header is empty' do
+      expect {
+        env = subject.call('HTTP_ACCEPT' => '').last
+      }.to throw_symbol(
+        :error,
+        :status => 406,
+        :headers => {'X-Cascade' => 'pass'},
+        :message => 'Accept header must be set'
+      )
     end
 
-    it 'should throw 406 error with X-Cascade header set to pass' do
+    it 'should fail with 406 Not Acceptable if type is a range' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => accept).last
-      }.to throw_symbol(:error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found")
+        env = subject.call('HTTP_ACCEPT' => '*/*').last
+      }.to throw_symbol(
+        :error,
+        :status => 406,
+        :headers => {'X-Cascade' => 'pass'},
+        :message => 'Accept header must not contain ranges ("*")'
+      )
+    end
+
+    it 'should fail with 406 Not Acceptable if subtype is a range' do
+      expect {
+        env = subject.call('HTTP_ACCEPT' => 'application/*').last
+      }.to throw_symbol(
+        :error,
+        :status => 406,
+        :headers => {'X-Cascade' => 'pass'},
+        :message => 'Accept header must not contain ranges ("*")'
+      )
+    end
+
+    it 'should succeed if proper header is set' do
+      subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json').first.should == 200
     end
   end
 end