grape 0.1.5 → 0.2.0

data/spec/grape/endpoint_spec.rb

@@ -2,71 +2,157 @@ require 'spec_helper'
 
 describe Grape::Endpoint do
   subject { Class.new(Grape::API) }
-  before { subject.default_format :txt }
   def app; subject end
-  
+
+  describe '#initialize' do
+    it 'should take a settings stack, options, and a block' do
+      expect{ Grape::Endpoint.new(Grape::Util::HashStack.new, {
+        :path => '/',
+        :method => :get
+      }, &Proc.new{}) }.not_to raise_error
+    end
+  end
+
+  it 'should set itself in the env upon call' do
+    subject.get('/'){ "Hello world." }
+    get '/'
+    last_request.env['api.endpoint'].should be_kind_of(Grape::Endpoint)
+  end
+
   describe '#status' do
     it 'should be callable from within a block' do
       subject.get('/home') do
         status 206
         "Hello"
       end
-      
+
       get '/home'
       last_response.status.should == 206
       last_response.body.should == "Hello"
     end
   end
-  
+
   describe '#header' do
     it 'should be callable from within a block' do
       subject.get('/hey') do
         header 'X-Awesome', 'true'
         "Awesome"
       end
-      
+
       get '/hey'
       last_response.headers['X-Awesome'].should == 'true'
     end
   end
+
+  describe '#cookies' do
+    it 'should be callable from within a block' do
+      subject.get('/get/cookies') do
+        cookies['my-awesome-cookie1'] = 'is cool'
+        cookies['my-awesome-cookie2'] = {
+            :value => 'is cool too',
+            :domain => 'my.example.com',
+            :path => '/',
+            :secure => true,
+        }
+        cookies[:cookie3] = 'symbol'
+        cookies['cookie4'] = 'secret code here'
+      end
+
+      get('/get/cookies')
+
+      last_response.headers['Set-Cookie'].split("\n").sort.should eql [
+        "cookie3=symbol",
+        "cookie4=secret+code+here",
+        "my-awesome-cookie1=is+cool",
+        "my-awesome-cookie2=is+cool+too; domain=my.example.com; path=/; secure"
+      ]
+    end
+
+    it "should set browser cookies and should not set response cookies" do
+      subject.get('/username') do
+        cookies[:username]
+      end
+      get('/username', {}, 'HTTP_COOKIE' => 'username=mrplum; sandbox=true')
+
+      last_response.body.should == 'mrplum'
+      last_response.headers['Set-Cookie'].should_not =~ /username=mrplum/
+      last_response.headers['Set-Cookie'].should_not =~ /sandbox=true/
+    end
+
+    it "should set and update browser cookies" do
+      subject.get('/username') do
+        cookies[:sandbox] = true if cookies[:sandbox] == 'false'
+        cookies[:username] += "_test"
+      end
+      get('/username', {}, 'HTTP_COOKIE' => 'username=user; sandbox=false')
+      last_response.body.should == 'user_test'
+      last_response.headers['Set-Cookie'].should =~ /username=user_test/
+      last_response.headers['Set-Cookie'].should =~ /sandbox=true/
+    end
+
+    it "should delete cookie" do
+      subject.get('/test') do
+        sum = 0
+        cookies.each do |name, val|
+          sum += val.to_i
+          cookies.delete name
+        end
+        sum
+      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"
+      ]
+    end
+  end
   
   describe '#params' do
     it 'should be available to the caller' do
       subject.get('/hey') do
         params[:howdy]
       end
-      
+
       get '/hey?howdy=hey'
       last_response.body.should == 'hey'
     end
-    
+
     it 'should parse from path segments' do
       subject.get('/hey/:id') do
         params[:id]
       end
-      
+
       get '/hey/12'
       last_response.body.should == '12'
     end
+
+    it 'should deeply convert nested params' do
+      subject.get '/location' do
+        params[:location][:city]
+      end
+      get '/location?location[city]=Dallas'
+      last_response.body.should == 'Dallas'
+    end
   end
-  
+
   describe '#error!' do
     it 'should accept a message' do
       subject.get('/hey') do
         error! "This is not valid."
         "This is valid."
       end
-      
+
       get '/hey'
       last_response.status.should == 403
       last_response.body.should == "This is not valid."
     end
-    
+
     it 'should accept a code' do
       subject.get('/hey') do
         error! "Unauthorized.", 401
       end
-      
+
       get '/hey'
       last_response.status.should == 401
       last_response.body.should == "Unauthorized."
@@ -82,33 +168,145 @@ describe Grape::Endpoint do
       last_response.body.should == '{"dude":"rad"}'
     end
   end
-  
+
   it 'should not persist params between calls' do
     subject.post('/new') do
       params[:text]
     end
-    
+
     post '/new', :text => 'abc'
     last_response.body.should == 'abc'
-    
+
     post '/new', :text => 'def'
     last_response.body.should == 'def'
   end
-  
+
   it 'should reset all instance variables (except block) between calls' do
     subject.helpers do
       def memoized
         @memoized ||= params[:howdy]
       end
     end
-    
+
     subject.get('/hello') do
       memoized
     end
-    
+
     get '/hello?howdy=hey'
     last_response.body.should == 'hey'
     get '/hello?howdy=yo'
     last_response.body.should == 'yo'
   end
+
+  describe '#present' do
+    it 'should just set 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 'should call 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 'should pull 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 'should pull 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 'should add 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 'filters' do
+    describe 'before filters' do
+      it 'should run the before filter if set' do
+        subject.before{ env['before_test'] = "OK" }
+        subject.get('/before_test'){ env['before_test'] }
+
+        get '/before_test'
+        last_response.body.should == "OK"
+      end
+    end
+
+    describe 'after filters' do
+      it 'should override the response body if it sets it' do
+        subject.after{ body "after" }
+        subject.get('/after_test'){ "during" }
+        get '/after_test'
+        last_response.body.should == 'after'
+      end
+
+      it 'should not override the response body with its return' do
+        subject.after{ "after" }
+        subject.get('/after_test'){ "body" }
+        get '/after_test'
+        last_response.body.should == "body"
+      end
+    end
+  end
+
+  context 'anchoring' do
+    verbs = %w(post get head delete put options patch)
+
+    verbs.each do |verb|
+      it "should allow for the anchoring option with a #{verb.upcase} method" do
+        subject.send(verb, '/example', :anchor => true) do
+          verb
+        end
+        send(verb, '/example/and/some/more')
+        last_response.status.should eql 404
+      end
+
+      it "should anchor paths by default for the #{verb.upcase} method" do
+        subject.send(verb, '/example') do
+          verb
+        end
+        send(verb, '/example/and/some/more')
+        last_response.status.should eql 404
+      end
+
+      it "should respond to /example/and/some/more for the non-anchored #{verb.upcase} method" do
+        subject.send(verb, '/example', :anchor => false) do
+          verb
+        end
+        send(verb, '/example/and/some/more')
+        last_response.status.should eql (verb == "post" ? 201 : 200)
+        last_response.body.should eql verb
+      end
+    end
+  end
 end

data/spec/grape/entity_spec.rb

@@ -0,0 +1,320 @@
+require 'spec_helper'
+
+describe Grape::Entity do
+  let(:fresh_class){ Class.new(Grape::Entity) }
+
+  context 'class methods' do
+    subject{ fresh_class }
+
+    describe '.expose' do
+      context 'multiple attributes' do
+        it 'should be able to add multiple exposed attributes with a single call' do
+          subject.expose :name, :email, :location
+          subject.exposures.size.should == 3
+        end
+
+        it 'should set 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 'should make 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
+      end
+
+      context 'with a block' do
+        it 'should error out if called with multiple attributes' do
+          expect{ subject.expose(:name, :email) do
+            true
+          end }.to raise_error(ArgumentError)
+        end
+
+        it 'should set the :proc option in the exposure options' do
+          block = lambda{|obj,opts| true }
+          subject.expose :name, &block
+          subject.exposures[:name][:proc].should == block
+        end
+      end
+
+      context 'inherited exposures' do
+        it 'should return exposures from an ancestor' do
+          subject.expose :name, :email
+          child_class = Class.new(subject)
+
+          child_class.exposures.should eq(subject.exposures)
+        end
+
+        it 'should return 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 'should return descendant exposures as a priotity' do
+          subject.expose :name, :email
+          child_class = Class.new(subject)
+          child_class.expose :name do |n|
+            'foo'
+          end
+
+          subject.exposures[:name].should_not have_key :proc
+          child_class.exposures[:name].should have_key :proc
+        end
+      end
+    end
+
+    describe '.represent' do
+      it 'should return a single entity if called with one object' do
+        subject.represent(Object.new).should be_kind_of(subject)
+      end
+
+      it 'should return a single entity if called with a hash' do
+        subject.represent(Hash.new).should be_kind_of(subject)
+      end
+
+      it 'should return 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 'should add 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}
+      end
+    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 'should allow 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
+
+        context 'with an array of objects' do
+          it 'should allow 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
+
+        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
+      end
+
+      context 'with singular root key' do
+        before(:each) do
+          subject.root nil, 'thing'
+        end
+
+        context 'with a single object' do
+          it 'should allow 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
+
+        context 'with an array of objects' do
+          it 'should allow 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
+      end
+
+      context 'with plural root key' do
+        before(:each) do
+          subject.root 'things'
+        end
+
+        context 'with a single object' do
+          it 'should allow a root element name to be specified' do
+            subject.represent(Object.new).should be_kind_of(subject)
+          end
+        end
+
+        context 'with an array of objects' do
+          it 'should allow 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
+      end
+    end
+
+    describe '#initialize' do
+      it 'should take 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 'should have attribute readers for the object and options' do
+        entity = subject.new('abc', {})
+        entity.object.should == 'abc'
+        entity.options.should == {}
+      end
+    end
+  end
+
+  context 'instance methods' do
+    let(:model){ mock(attributes) }
+    let(:attributes){ {
+      :name => 'Bob Bobson',
+      :email => 'bob@example.com',
+      :friends => [
+        mock(:name => "Friend 1", :email => 'friend1@example.com', :friends => []),
+        mock(:name => "Friend 2", :email => 'friend2@example.com', :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
+
+      it 'should 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
+    end
+
+    describe '#value_for' do
+      before do
+        fresh_class.class_eval do
+          expose :name, :email
+          expose :friends, :using => self
+          expose :computed do |object, options|
+            options[:awesome]
+          end
+        end
+      end
+
+      it 'should pass through bare expose attributes' do
+        subject.send(:value_for, :name).should == attributes[:name]
+      end
+
+      it 'should instantiate 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'
+      end
+
+      it 'should disable root key name for child representations' do
+        class FriendEntity < Grape::Entity
+          root 'friends', 'friend'
+          expose :name, :email
+        end
+        fresh_class.class_eval do
+          expose :friends, :using => FriendEntity
+        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'
+      end
+
+      it 'should call through to the proc if there is one' do
+        subject.send(:value_for, :computed, :awesome => 123).should == 123
+      end
+    end
+
+    describe '#key_for' do
+      it 'should return the attribute if no :as is set' do
+        fresh_class.expose :name
+        subject.send(:key_for, :name).should == :name
+      end
+
+      it 'should return a symbolized version of the attribute' do
+        fresh_class.expose :name
+        subject.send(:key_for, 'name').should == :name
+      end
+
+      it 'should return the :as alias if one exists' do
+        fresh_class.expose :name, :as => :nombre
+        subject.send(:key_for, 'name').should == :nombre
+      end
+    end
+
+    describe '#conditions_met?' do
+      it 'should only pass through hash :if exposure if all attributes match' do
+        exposure_options = {:if => {:condition1 => true, :condition2 => true}}
+
+        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 'should only pass through proc :if exposure if it returns truthy value' do
+        exposure_options = {:if => lambda{|obj,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 'should only pass through hash :unless exposure if any attributes do not match' do
+        exposure_options = {:unless => {:condition1 => true, :condition2 => true}}
+
+        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 'should only pass through proc :unless exposure if it returns falsy value' do
+        exposure_options = {:unless => lambda{|object,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
+  end
+end