grape 0.2.6 → 0.3.0

data/spec/grape/endpoint_spec.rb

@@ -47,6 +47,25 @@ describe Grape::Endpoint do
     end
   end
 
+  describe '#headers' do
+    before do
+      subject.get('/headers') do
+        headers.to_json
+      end
+    end
+    it 'includes request headers' do
+      get '/headers'
+      JSON.parse(last_response.body).should == {
+        "Host" => "example.org",
+        "Cookie" => ""
+      }
+    end
+    it 'includes additional request headers' do
+      get '/headers', nil, { "HTTP_X_GRAPE_CLIENT" => "1" }
+      JSON.parse(last_response.body)["X-Grape-Client"].should == "1"
+    end
+  end
+
   describe '#cookies' do
     it 'is callable from within a block' do
       subject.get('/get/cookies') do
@@ -104,10 +123,17 @@ describe Grape::Endpoint do
       end
       get('/test', {}, 'HTTP_COOKIE' => 'delete_this_cookie=1; and_this=2')
       last_response.body.should == '3'
-      last_response.headers['Set-Cookie'].split("\n").sort.should == [
-          "and_this=deleted; expires=Thu, 01-Jan-1970 00:00:00 GMT",
-          "delete_this_cookie=deleted; expires=Thu, 01-Jan-1970 00:00:00 GMT"
-      ]
+      cookies = Hash[last_response.headers['Set-Cookie'].split("\n").map do |set_cookie|
+        cookie = CookieJar::Cookie.from_set_cookie 'http://localhost/test', set_cookie
+        [ cookie.name, cookie ]
+      end]
+      cookies.size.should == 2
+      [ "and_this", "delete_this_cookie" ].each do |cookie_name|
+        cookie = cookies[cookie_name]
+        cookie.should_not be_nil
+        cookie.value.should == "deleted"
+        cookie.expired?.should be_true
+      end
     end
 
     it 'deletes cookies with path' do
@@ -121,10 +147,18 @@ describe Grape::Endpoint do
       end
       get('/test', {}, 'HTTP_COOKIE' => 'delete_this_cookie=1; and_this=2')
       last_response.body.should == '3'
-      last_response.headers['Set-Cookie'].split("\n").sort.should == [
-          "and_this=deleted; path=/test; expires=Thu, 01-Jan-1970 00:00:00 GMT",
-          "delete_this_cookie=deleted; path=/test; expires=Thu, 01-Jan-1970 00:00:00 GMT"
-      ]
+      cookies = Hash[last_response.headers['Set-Cookie'].split("\n").map do |set_cookie|
+        cookie = CookieJar::Cookie.from_set_cookie 'http://localhost/test', set_cookie
+        [ cookie.name, cookie ]
+      end]
+      cookies.size.should == 2
+      [ "and_this", "delete_this_cookie" ].each do |cookie_name|
+        cookie = cookies[cookie_name]
+        cookie.should_not be_nil
+        cookie.value.should == "deleted"
+        cookie.path.should == "/test"
+        cookie.expired?.should be_true
+      end
     end
   end
 
@@ -288,7 +322,7 @@ describe Grape::Endpoint do
       end
       put '/request_body', '<user>Bobby T.</user>', {'CONTENT_TYPE' => 'application/xml'}
       last_response.status.should == 406
-      last_response.body.should == '{"error":"The requested content-type is not supported."}'
+      last_response.body.should == '{"error":"The requested content-type \'application/xml\' is not supported."}'
     end
 
   end
@@ -412,148 +446,6 @@ describe Grape::Endpoint do
     end
   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'}
-      end
-      get '/example'
-    end
-
-    it 'calls through to the provided entity class if one is given' do
-      subject.get '/example' do
-        entity_mock = Object.new
-        entity_mock.should_receive(:represent)
-        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")
-
-      subject.represent Object, :with => entity
-      subject.get '/example' do
-        present Object.new
-      end
-      get '/example'
-      last_response.body.should == 'Hiya'
-    end
-
-    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")
-
-      class TestObject; end
-
-      subject.represent TestObject, :with => entity
-      subject.get '/example' do
-        present [TestObject.new]
-      end
-      get '/example'
-      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")
-
-      subclass = Class.new(Object)
-
-      subject.represent Object, :with => entity
-      subject.get '/example' do
-        present subclass.new
-      end
-      get '/example'
-      last_response.body.should == 'Hiya'
-    end
-
-    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!")
-
-      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 '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!")
-
-      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 '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'}}
-      end
-      get '/example'
-    end
-
-    [ :json, :serializable_hash ].each do |format|
-
-      it 'presents with #{format}' do
-        entity = Class.new(Grape::Entity)
-        entity.root "examples", "example"
-        entity.expose :id
-
-        subject.format format
-        subject.get '/example' do
-          c = Class.new do
-            attr_reader :id
-            def initialize(id)
-              @id = id
-            end
-          end
-          present c.new(1), :with => entity
-        end
-
-        get '/example'
-        last_response.status.should == 200
-        last_response.body.should == '{"example":{"id":1}}'
-      end
-
-      it 'presents with #{format} collection' do
-        entity = Class.new(Grape::Entity)
-        entity.root "examples", "example"
-        entity.expose :id
-
-        subject.format format
-        subject.get '/examples' do
-          c = Class.new do
-            attr_reader :id
-            def initialize(id)
-              @id = id
-            end
-          end
-          examples = [ c.new(1), c.new(2) ]
-          present examples, :with => entity
-        end
-
-        get '/examples'
-        last_response.status.should == 200
-        last_response.body.should == '{"examples":[{"id":1},{"id":2}]}'
-      end
-
-    end
-  end
-
   context 'filters' do
     describe 'before filters' do
       it 'runs the before filter if set' do
@@ -621,13 +513,15 @@ describe Grape::Endpoint do
       get '/url'
       last_response.body.should == "http://example.org/url"
     end
-    it 'should include version' do
-      subject.version 'v1', :using => :path
-      subject.get('/url') do
-        request.url
+    [ 'v1', :v1 ].each do |version|
+      it 'should include version #{version}' do
+        subject.version version, :using => :path
+        subject.get('/url') do
+          request.url
+        end
+        get "/#{version}/url"
+        last_response.body.should == "http://example.org/#{version}/url"
       end
-      get '/v1/url'
-      last_response.body.should == "http://example.org/v1/url"
     end
     it 'should include prefix' do
       subject.version 'v1', :using => :path

data/spec/grape/entity_spec.rb

@@ -1,579 +1,201 @@
 require 'spec_helper'
+require 'grape_entity'
 
 describe Grape::Entity do
-  let(:fresh_class) { Class.new(Grape::Entity) }
+  subject { Class.new(Grape::API) }
+  def app; subject end
 
-  context 'class methods' do
-    subject { fresh_class }
-
-    describe '.expose' do
-      context 'multiple attributes' do
-        it 'is able to add multiple exposed attributes with a single call' do
-          subject.expose :name, :email, :location
-          subject.exposures.size.should == 3
-        end
-
-        it 'sets the same options for all exposures passed' do
-          subject.expose :name, :email, :location, :foo => :bar
-          subject.exposures.values.each{|v| v.should == {:foo => :bar}}
-        end
-      end
-
-      context 'option validation' do
-        it 'makes sure that :as only works on single attribute calls' do
-          expect{ subject.expose :name, :email, :as => :foo }.to raise_error(ArgumentError)
-          expect{ subject.expose :name, :as => :foo }.not_to raise_error
-        end
-
-        it 'makes sure that :format_with as a proc can not be used with a block' do
-          expect { subject.expose :name, :format_with => Proc.new {} do |_| end }.to raise_error(ArgumentError)
-        end
-      end
-
-      context 'with a block' do
-        it 'errors out if called with multiple attributes' do
-          expect{ subject.expose(:name, :email) do
-            true
-          end }.to raise_error(ArgumentError)
-        end
-
-        it 'sets the :proc option in the exposure options' do
-          block = lambda{|_| true }
-          subject.expose :name, &block
-          subject.exposures[:name][:proc].should == block
-        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'}
       end
+      get '/example'
+    end
 
-      context 'inherited exposures' do
-        it 'returns exposures from an ancestor' do
-          subject.expose :name, :email
-          child_class = Class.new(subject)
-
-          child_class.exposures.should eq(subject.exposures)
-        end
-
-        it 'returns exposures from multiple ancestor' do
-          subject.expose :name, :email
-          parent_class = Class.new(subject)
-          child_class  = Class.new(parent_class)
-
-          child_class.exposures.should eq(subject.exposures)
-        end
-
-        it 'returns descendant exposures as a priority' do
-          subject.expose :name, :email
-          child_class = Class.new(subject)
-          child_class.expose :name do |_|
-            'foo'
-          end
-
-          subject.exposures[:name].should_not have_key :proc
-          child_class.exposures[:name].should have_key :proc
-        end
+    it 'calls through to the provided entity class if one is given' do
+      subject.get '/example' do
+        entity_mock = Object.new
+        entity_mock.should_receive(:represent)
+        present Object.new, :with => entity_mock
       end
+      get '/example'
+    end
 
-      context 'register formatters' do
-        let(:date_formatter) { lambda {|date| date.strftime('%m/%d/%Y') }}
-
-        it 'registers a formatter' do
-          subject.format_with :timestamp, &date_formatter
-
-          subject.formatters[:timestamp].should_not be_nil
-        end
-
-        it 'inherits formatters from ancestors' do
-          subject.format_with :timestamp, &date_formatter
-          child_class = Class.new(subject)
-
-          child_class.formatters.should == subject.formatters
-        end
-
-        it 'does not allow registering a formatter without a block' do
-          expect{ subject.format_with :foo }.to raise_error(ArgumentError)
-        end
-
-        it 'formats an exposure with a registered formatter' do
-          subject.format_with :timestamp do |date|
-            date.strftime('%m/%d/%Y')
-          end
-
-          subject.expose :birthday, :format_with => :timestamp
+    it 'pulls a representation from the class options if it exists' do
+      entity = Class.new(Grape::Entity)
+      entity.stub!(:represent).and_return("Hiya")
 
-          model  = { :birthday => Time.gm(2012, 2, 27) }
-          subject.new(mock(model)).as_json[:birthday].should == '02/27/2012'
-        end
+      subject.represent Object, :with => entity
+      subject.get '/example' do
+        present Object.new
       end
+      get '/example'
+      last_response.body.should == 'Hiya'
     end
 
-    describe '.represent' do
-      it 'returns a single entity if called with one object' do
-        subject.represent(Object.new).should be_kind_of(subject)
-      end
+    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")
 
-      it 'returns a single entity if called with a hash' do
-        subject.represent(Hash.new).should be_kind_of(subject)
-      end
+      class TestObject; end
 
-      it 'returns multiple entities if called with a collection' do
-        representation = subject.represent(4.times.map{Object.new})
-        representation.should be_kind_of Array
-        representation.size.should == 4
-        representation.reject{|r| r.kind_of?(subject)}.should be_empty
-      end
-
-      it 'adds the :collection => true option if called with a collection' do
-        representation = subject.represent(4.times.map{Object.new})
-        representation.each{|r| r.options[:collection].should be_true}
+      subject.represent TestObject, :with => entity
+      subject.get '/example' do
+        present [TestObject.new]
       end
+      get '/example'
+      last_response.body.should == "Hiya"
     end
 
-    describe '.root' do
-      context 'with singular and plural root keys' do
-        before(:each) do
-          subject.root 'things', 'thing'
-        end
-
-        context 'with a single object' do
-          it 'allows a root element name to be specified' do
-            representation = subject.represent(Object.new)
-            representation.should be_kind_of Hash
-            representation.should have_key 'thing'
-            representation['thing'].should be_kind_of(subject)
-          end
-        end
+    it 'pulls a representation from the class ancestor if it exists' do
+      entity = Class.new(Grape::Entity)
+      entity.stub!(:represent).and_return("Hiya")
 
-        context 'with an array of objects' do
-          it 'allows a root element name to be specified' do
-            representation = subject.represent(4.times.map{Object.new})
-            representation.should be_kind_of Hash
-            representation.should have_key 'things'
-            representation['things'].should be_kind_of Array
-            representation['things'].size.should == 4
-            representation['things'].reject{|r| r.kind_of?(subject)}.should be_empty
-          end
-        end
+      subclass = Class.new(Object)
 
-        context 'it can be overridden' do
-          it 'can be disabled' do
-            representation = subject.represent(4.times.map{Object.new}, :root=>false)
-            representation.should be_kind_of Array
-            representation.size.should == 4
-            representation.reject{|r| r.kind_of?(subject)}.should be_empty
-          end
-          it 'can use a different name' do
-            representation = subject.represent(4.times.map{Object.new}, :root=>'others')
-            representation.should be_kind_of Hash
-            representation.should have_key 'others'
-            representation['others'].should be_kind_of Array
-            representation['others'].size.should == 4
-            representation['others'].reject{|r| r.kind_of?(subject)}.should be_empty
-          end
-        end
+      subject.represent Object, :with => entity
+      subject.get '/example' do
+        present subclass.new
       end
+      get '/example'
+      last_response.body.should == 'Hiya'
+    end
 
-      context 'with singular root key' do
-        before(:each) do
-          subject.root nil, 'thing'
-        end
+    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!")
 
-        context 'with a single object' do
-          it 'allows a root element name to be specified' do
-            representation = subject.represent(Object.new)
-            representation.should be_kind_of Hash
-            representation.should have_key 'thing'
-            representation['thing'].should be_kind_of(subject)
-          end
-        end
+      some_model.const_set :Entity, entity
 
-        context 'with an array of objects' do
-          it 'allows a root element name to be specified' do
-            representation = subject.represent(4.times.map{Object.new})
-            representation.should be_kind_of Array
-            representation.size.should == 4
-            representation.reject{|r| r.kind_of?(subject)}.should be_empty
-          end
-        end
+      subject.get '/example' do
+        present some_model.new
       end
+      get '/example'
+      last_response.body.should == 'Auto-detect!'
+    end
 
-      context 'with plural root key' do
-        before(:each) do
-          subject.root 'things'
-        end
+    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!")
 
-        context 'with a single object' do
-          it 'allows a root element name to be specified' do
-            subject.represent(Object.new).should be_kind_of(subject)
-          end
-        end
+      some_model.const_set :Entity, entity
 
-        context 'with an array of objects' do
-          it 'allows a root element name to be specified' do
-            representation = subject.represent(4.times.map{Object.new})
-            representation.should be_kind_of Hash
-            representation.should have_key('things')
-            representation['things'].should be_kind_of Array
-            representation['things'].size.should == 4
-            representation['things'].reject{|r| r.kind_of?(subject)}.should be_empty
-          end
-        end
+      subject.get '/example' do
+        present [some_model.new]
       end
+      get '/example'
+      last_response.body.should == 'Auto-detect!'
     end
 
-    describe '#initialize' do
-      it 'takes an object and an optional options hash' do
-        expect{ subject.new(Object.new) }.not_to raise_error
-        expect{ subject.new }.to raise_error(ArgumentError)
-        expect{ subject.new(Object.new, {}) }.not_to raise_error
-      end
-
-      it 'has attribute readers for the object and options' do
-        entity = subject.new('abc', {})
-        entity.object.should == 'abc'
-        entity.options.should == {}
+    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'}}
       end
+      get '/example'
     end
-  end
-
-  context 'instance methods' do
-    
-    let(:model){ mock(attributes) }
-    
-    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 2", :email => 'friend2@example.com', :fantasies => [], :birthday => Time.gm(2012, 2, 27), :friends => [])
-      ]
-    } }
-    
-    subject{ fresh_class.new(model) }
-
-    describe '#serializable_hash' do
-
-      it 'does 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
-
-      it 'does not blow up when the model is nil' do
-        fresh_class.expose :name
-        expect{ fresh_class.new(nil).serializable_hash }.not_to raise_error
-      end
-
-      it 'does not throw an exception when an attribute is not found on the object' do
-        fresh_class.expose :name, :nonexistent_attribute
-        expect{ fresh_class.new(model).serializable_hash }.not_to raise_error
-      end
-
-      it "does not expose attributes that don't exist on the object" do
-        fresh_class.expose :email, :nonexistent_attribute, :name
-
-        res = fresh_class.new(model).serializable_hash
-        res.should have_key :email
-        res.should_not have_key :nonexistent_attribute
-        res.should have_key :name
-      end
-
-      it "does not expose attributes that don't exist on the object, even with criteria" do
-        fresh_class.expose :email
-        fresh_class.expose :nonexistent_attribute, :if => lambda { false }
-        fresh_class.expose :nonexistent_attribute2, :if => lambda { true }
-
-        res = fresh_class.new(model).serializable_hash
-        res.should have_key :email
-        res.should_not have_key :nonexistent_attribute
-        res.should_not have_key :nonexistent_attribute2
-      end
-
-      it "exposes attributes that don't exist on the object only when they are generated by a block" do
-        fresh_class.expose :nonexistent_attribute do |model, _|
-          "well, I do exist after all"
-        end
-        res = fresh_class.new(model).serializable_hash
-        res.should have_key :nonexistent_attribute
-      end
 
-      it "does not expose attributes that are generated by a block but have not passed criteria" do
-        fresh_class.expose :nonexistent_attribute, :proc => lambda {|model, _|
-          "I exist, but it is not yet my time to shine"
-        }, :if => lambda { |model, _| false }
-        res = fresh_class.new(model).serializable_hash
-        res.should_not have_key :nonexistent_attribute
-      end
+    [ :json, :serializable_hash ].each do |format|
 
-      context '#serializable_hash' do
+      it 'presents with #{format}' do
+        entity = Class.new(Grape::Entity)
+        entity.root "examples", "example"
+        entity.expose :id
 
-        module EntitySpec
-          class EmbeddedExample
-            def serializable_hash(opts = {})
-              { :abc => 'def' }
-            end
-          end
-          class EmbeddedExampleWithMany
-            def name
-              "abc"
-            end
-            def embedded
-              [ EmbeddedExample.new, EmbeddedExample.new ]
+        subject.format format
+        subject.get '/example' do
+          c = Class.new do
+            attr_reader :id
+            def initialize(id)
+              @id = id
             end
           end
-          class EmbeddedExampleWithOne
-            def name
-              "abc"
-            end
-            def embedded
-              EmbeddedExample.new
-            end
-          end
-        end
-      
-        it 'serializes 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 'serializes 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
-      before do
-        fresh_class.class_eval do
-          expose :name, :email
-          expose :friends, :using => self
-          expose :computed do |_, options|
-            options[:awesome]
-          end
-
-          expose :birthday, :format_with => :timestamp
-
-          def timestamp(date)
-            date.strftime('%m/%d/%Y')
-          end
-
-          expose :fantasies, :format_with => lambda {|f| f.reverse }
+          present c.new(1), :with => entity
         end
-      end
-
-      it 'passes through bare expose attributes' do
-        subject.send(:value_for, :name).should == attributes[:name]
-      end
 
-      it 'instantiates a representation if that is called for' do
-        rep = subject.send(:value_for, :friends)
-        rep.reject{|r| r.is_a?(fresh_class)}.should be_empty
-        rep.first.serializable_hash[:name].should == 'Friend 1'
-        rep.last.serializable_hash[:name].should == 'Friend 2'
+        get '/example'
+        last_response.status.should == 200
+        last_response.body.should == '{"example":{"id":1}}'
       end
 
-      context 'child representations' do
-        it 'disables 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
-
-        it 'passes 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
+      it 'presents with #{format} collection' do
+        entity = Class.new(Grape::Entity)
+        entity.root "examples", "example"
+        entity.expose :id
 
-        it 'ignores the :collection parameter in the source options' do
-          module EntitySpec
-            class FriendEntity < Grape::Entity
-              root 'friends', 'friend'
-              expose :name
-              expose :email, :if => { :collection => true }
+        subject.format format
+        subject.get '/examples' do
+          c = Class.new do
+            attr_reader :id
+            def initialize(id)
+              @id = id
             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'
+          examples = [ c.new(1), c.new(2) ]
+          present examples, :with => entity
         end
 
+        get '/examples'
+        last_response.status.should == 200
+        last_response.body.should == '{"examples":[{"id":1},{"id":2}]}'
       end
 
-      it 'calls through to the proc if there is one' do
-        subject.send(:value_for, :computed, :awesome => 123).should == 123
-      end
-
-      it 'returns a formatted value if format_with is passed' do
-        subject.send(:value_for, :birthday).should == '02/27/2012'
-      end
-
-      it 'returns a formatted value if format_with is passed a lambda' do
-        subject.send(:value_for, :fantasies).should == ['Nessy', 'Double Rainbows', 'Unicorns']
-      end
     end
 
-    describe '#documentation' do
-      it 'returns an empty hash is no documentation is provided' do
-        fresh_class.expose :name
-
-        subject.documentation.should == {}
-      end
-
-      it 'returns each defined documentation hash' do
-        doc = {:type => "foo", :desc => "bar"}
-        fresh_class.expose :name, :documentation => doc
-        fresh_class.expose :email, :documentation => doc
-        fresh_class.expose :birthday
-
-        subject.documentation.should == {:name  => doc, :email => doc}
-      end
-    end
-
-    describe '#key_for' do
-      it 'returns the attribute if no :as is set' do
-        fresh_class.expose :name
-        subject.send(:key_for, :name).should == :name
-      end
-
-      it 'returns a symbolized version of the attribute' do
-        fresh_class.expose :name
-        subject.send(:key_for, 'name').should == :name
-      end
-
-      it 'returns the :as alias if one exists' do
-        fresh_class.expose :name, :as => :nombre
-        subject.send(:key_for, 'name').should == :nombre
-      end
+    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 
+          attr_reader :name
+          def initialize(args)
+            @name = args[:name] || "no name set"
+          end
+        end
+        present c.new({:name => "johnnyiller"}), :with => entity
+      end
+      get '/example'
+      last_response.status.should == 200
+      last_response.headers['Content-type'].should == "application/xml"
+      last_response.body.should == <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<hash>
+  <example>
+    <name>johnnyiller</name>
+  </example>
+</hash>
+XML
     end
 
-    describe '#conditions_met?' do
-      it 'only passes through hash :if exposure if all attributes match' do
-        exposure_options = {:if => {:condition1 => true, :condition2 => true}}
+    it 'presents with json' do 
+      entity = Class.new(Grape::Entity)
+      entity.root "examples", "example"
+      entity.expose :name
 
-        subject.send(:conditions_met?, exposure_options, {}).should be_false
-        subject.send(:conditions_met?, exposure_options, :condition1 => true).should be_false
-        subject.send(:conditions_met?, exposure_options, :condition1 => true, :condition2 => true).should be_true
-        subject.send(:conditions_met?, exposure_options, :condition1 => false, :condition2 => true).should be_false
-        subject.send(:conditions_met?, exposure_options, :condition1 => true, :condition2 => true, :other => true).should be_true
-      end
-
-      it 'only passes through proc :if exposure if it returns truthy value' do
-        exposure_options = {:if => lambda{|_,opts| opts[:true]}}
-
-        subject.send(:conditions_met?, exposure_options, :true => false).should be_false
-        subject.send(:conditions_met?, exposure_options, :true => true).should be_true
-      end
-
-      it 'only passes through hash :unless exposure if any attributes do not match' do
-        exposure_options = {:unless => {:condition1 => true, :condition2 => true}}
+      subject.format :json
 
-        subject.send(:conditions_met?, exposure_options, {}).should be_true
-        subject.send(:conditions_met?, exposure_options, :condition1 => true).should be_false
-        subject.send(:conditions_met?, exposure_options, :condition1 => true, :condition2 => true).should be_false
-        subject.send(:conditions_met?, exposure_options, :condition1 => false, :condition2 => true).should be_false
-        subject.send(:conditions_met?, exposure_options, :condition1 => true, :condition2 => true, :other => true).should be_false
-        subject.send(:conditions_met?, exposure_options, :condition1 => false, :condition2 => false).should be_true
-      end
-
-      it 'only passes through proc :unless exposure if it returns falsy value' do
-        exposure_options = {:unless => lambda{|_,options| options[:true] == true}}
-
-        subject.send(:conditions_met?, exposure_options, :true => false).should be_true
-        subject.send(:conditions_met?, exposure_options, :true => true).should be_false
-      end
-    end
-
-    describe '::DSL' do
-      subject{ Class.new }
-
-      it 'creates 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 'is able to define entity traits through DSL' do
-          subject.entity do
-            expose :name
-          end
-
-          subject.entity_class.exposures.should_not be_empty
-        end
-
-        it 'is able to expose straight from the class' do
-          subject.entity :name, :email
-          subject.entity_class.exposures.size.should == 2
-        end
-
-        it 'is 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 'is an instance of the entity class' do
-              instance.entity.should be_kind_of(subject.entity_class)
-            end
-
-            it 'has an object of itself' do
-              instance.entity.object.should == instance
-            end
+      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'
+      last_response.status.should == 200
+      last_response.headers['Content-type'].should == "application/json"
+      last_response.body.should == '{"example":{"name":"johnnyiller"}}'
     end
   end
-end
+
+end