grape 0.2.3 → 0.2.4

data/spec/grape/entity_spec.rb

@@ -8,36 +8,36 @@ describe Grape::Entity do
 
     describe '.expose' do
       context 'multiple attributes' do
-        it 'should be able to add multiple exposed attributes with a single call' 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 'should set the same options for all exposures passed' do
+        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 'should make sure that :as only works on single attribute calls' 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 'should make sure that :format_with as a proc can not be used with a block' do
+        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 'should error out if called with multiple attributes' do
+        it 'errors 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
+        it 'sets the :proc option in the exposure options' do
           block = lambda{|_| true }
           subject.expose :name, &block
           subject.exposures[:name][:proc].should == block
@@ -45,14 +45,14 @@ describe Grape::Entity do
       end
 
       context 'inherited exposures' do
-        it 'should return exposures from an ancestor' 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 'should return exposures from multiple ancestor' do
+        it 'returns exposures from multiple ancestor' do
           subject.expose :name, :email
           parent_class = Class.new(subject)
           child_class  = Class.new(parent_class)
@@ -60,7 +60,7 @@ describe Grape::Entity do
           child_class.exposures.should eq(subject.exposures)
         end
 
-        it 'should return descendant exposures as a priority' do
+        it 'returns descendant exposures as a priority' do
           subject.expose :name, :email
           child_class = Class.new(subject)
           child_class.expose :name do |_|
@@ -75,24 +75,24 @@ describe Grape::Entity do
       context 'register formatters' do
         let(:date_formatter) { lambda {|date| date.strftime('%m/%d/%Y') }}
 
-        it 'should register a formatter' do
+        it 'registers a formatter' do
           subject.format_with :timestamp, &date_formatter
 
           subject.formatters[:timestamp].should_not be_nil
         end
 
-        it 'should inherit formatters from ancestors' do
+        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 'should not allow registering a formatter without a block' do
+        it 'does not allow registering a formatter without a block' do
           expect{ subject.format_with :foo }.to raise_error(ArgumentError)
         end
 
-        it 'should format an exposure with a registered formatter' do
+        it 'formats an exposure with a registered formatter' do
           subject.format_with :timestamp do |date|
             date.strftime('%m/%d/%Y')
           end
@@ -106,22 +106,22 @@ describe Grape::Entity do
     end
 
     describe '.represent' do
-      it 'should return a single entity if called with one object' do
+      it 'returns 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
+      it 'returns 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
+      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.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
+      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}
       end
@@ -134,20 +134,20 @@ describe Grape::Entity do
         end
 
         context 'with a single object' do
-          it 'should allow a root element name to be specified' 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.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
+          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.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
@@ -156,15 +156,15 @@ describe Grape::Entity do
         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.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.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
@@ -177,18 +177,18 @@ describe Grape::Entity do
         end
 
         context 'with a single object' do
-          it 'should allow a root element name to be specified' 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.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
+          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.should be_kind_of Array
             representation.size.should == 4
             representation.reject{|r| r.kind_of?(subject)}.should be_empty
           end
@@ -201,17 +201,17 @@ describe Grape::Entity do
         end
 
         context 'with a single object' do
-          it 'should allow a root element name to be specified' do
+          it 'allows 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
+          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 be_kind_of Hash
             representation.should have_key('things')
-            representation['things'].should be_kind_of(Array)
+            representation['things'].should be_kind_of Array
             representation['things'].size.should == 4
             representation['things'].reject{|r| r.kind_of?(subject)}.should be_empty
           end
@@ -220,13 +220,13 @@ describe Grape::Entity do
     end
 
     describe '#initialize' do
-      it 'should take an object and an optional options hash' 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 'should have attribute readers for the object and options' do
+      it 'has attribute readers for the object and options' do
         entity = subject.new('abc', {})
         entity.object.should == 'abc'
         entity.options.should == {}
@@ -253,21 +253,21 @@ describe Grape::Entity do
 
     describe '#serializable_hash' do
 
-      it 'should not throw an exception if a nil options object is passed' 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 'should not blow up when the model is nil' do
+      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 'should not throw an exception when an attribute is not found on the object' do
+      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 "should not expose attributes that don't exist on the object" do
+      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
@@ -276,7 +276,7 @@ describe Grape::Entity do
         res.should have_key :name
       end
 
-      it "should not expose attributes that don't exist on the object, even with criteria" do
+      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 }
@@ -287,7 +287,7 @@ describe Grape::Entity do
         res.should_not have_key :nonexistent_attribute2
       end
 
-      it "should expose attributes that don't exist on the object only when they are generated by a block" do
+      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
@@ -295,7 +295,7 @@ describe Grape::Entity do
         res.should have_key :nonexistent_attribute
       end
 
-      it "should not expose attributes that are generated by a block but have not passed criteria" do
+      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 }
@@ -303,7 +303,7 @@ describe Grape::Entity do
         res.should_not have_key :nonexistent_attribute
       end
 
-      context "#serializable_hash" do
+      context '#serializable_hash' do
 
         module EntitySpec
           class EmbeddedExample
@@ -329,13 +329,13 @@ describe Grape::Entity do
           end
         end
       
-        it 'should serialize embedded objects which respond to #serializable_hash' do
+        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 'should serialize embedded arrays of objects which respond to #serializable_hash' do
+        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"}]}
@@ -364,11 +364,11 @@ describe Grape::Entity do
         end
       end
 
-      it 'should pass through bare expose attributes' do
+      it 'passes 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
+      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'
@@ -376,7 +376,7 @@ describe Grape::Entity do
       end
 
       context 'child representations' do
-        it 'should disable root key name for child representations' do
+        it 'disables root key name for child representations' do
         
           module EntitySpec
             class FriendEntity < Grape::Entity
@@ -390,13 +390,13 @@ describe Grape::Entity do
           end
           
           rep = subject.send(:value_for, :friends)
-          rep.should be_kind_of(Array)
+          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 'should pass through custom options' do
+        it 'passes through custom options' do
           module EntitySpec
             class FriendEntity < Grape::Entity
               root 'friends', 'friend'
@@ -410,19 +410,19 @@ describe Grape::Entity do
           end
           
           rep = subject.send(:value_for, :friends)
-          rep.should be_kind_of(Array)
+          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.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 'should ignore the :collection parameter in the source options' do
+        it 'ignores the :collection parameter in the source options' do
           module EntitySpec
             class FriendEntity < Grape::Entity
               root 'friends', 'friend'
@@ -436,7 +436,7 @@ describe Grape::Entity do
           end
           
           rep = subject.send(:value_for, :friends, { :collection => false })
-          rep.should be_kind_of(Array)
+          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'
@@ -444,27 +444,27 @@ describe Grape::Entity do
 
       end
 
-      it 'should call through to the proc if there is one' do
+      it 'calls through to the proc if there is one' do
         subject.send(:value_for, :computed, :awesome => 123).should == 123
       end
 
-      it 'should return a formatted value if format_with is passed' do
+      it 'returns a formatted value if format_with is passed' do
         subject.send(:value_for, :birthday).should == '02/27/2012'
       end
 
-      it 'should return a formatted value if format_with is passed a lambda' do
+      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 'should return an empty hash is no documentation is provided' do
+      it 'returns an empty hash is no documentation is provided' do
         fresh_class.expose :name
 
         subject.documentation.should == {}
       end
 
-      it 'should return each defined documentation hash' do
+      it 'returns each defined documentation hash' do
         doc = {:type => "foo", :desc => "bar"}
         fresh_class.expose :name, :documentation => doc
         fresh_class.expose :email, :documentation => doc
@@ -475,24 +475,24 @@ describe Grape::Entity do
     end
 
     describe '#key_for' do
-      it 'should return the attribute if no :as is set' do
+      it 'returns 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
+      it 'returns 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
+      it 'returns 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
+      it 'only passes 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
@@ -502,14 +502,14 @@ describe Grape::Entity do
         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
+      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 'should only pass through hash :unless exposure if any attributes do not match' do
+      it 'only passes 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
@@ -520,7 +520,7 @@ describe Grape::Entity do
         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
+      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
@@ -528,19 +528,19 @@ describe Grape::Entity do
       end
     end
 
-    describe "::DSL" do
+    describe '::DSL' do
       subject{ Class.new }
 
-      it 'should create an Entity class when called' do
-        subject.should_not be_const_defined(:Entity)
+      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)
+        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
+        it 'is able to define entity traits through DSL' do
           subject.entity do
             expose :name
           end
@@ -548,12 +548,12 @@ describe Grape::Entity do
           subject.entity_class.exposures.should_not be_empty
         end
 
-        it 'should be able to expose straight from the class' do
+        it 'is 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
+        it 'is able to mix field and advanced exposures' do
           subject.entity :name, :email do
             expose :third
           end
@@ -564,11 +564,11 @@ describe Grape::Entity do
           let(:instance){ subject.new }
 
           describe '#entity' do
-            it 'should be an instance of the entity class' do
+            it 'is 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
+            it 'has an object of itself' do
               instance.entity.object.should == instance
             end
           end