grape-entity 0.6.0 → 0.10.1

data/spec/grape_entity/entity_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'ostruct'
 
@@ -27,7 +29,9 @@ describe Grape::Entity do
         end
 
         it 'makes sure that :format_with as a proc cannot be used with a block' do
-          expect { subject.expose :name, format_with: proc {} {} }.to raise_error ArgumentError
+          # rubocop:disable Style/BlockDelimiters
+          expect { subject.expose :name, format_with: proc {} do p 'hi' end }.to raise_error ArgumentError
+          # rubocop:enable Style/BlockDelimiters
         end
 
         it 'makes sure unknown options are not silently ignored' do
@@ -64,6 +68,274 @@ describe Grape::Entity do
         end
       end
 
+      context 'with :expose_nil option' do
+        let(:a) { nil }
+        let(:b) { nil }
+        let(:c) { 'value' }
+
+        context 'when model is a PORO' do
+          let(:model) { Model.new(a, b, c) }
+
+          before do
+            stub_const 'Model', Class.new
+            Model.class_eval do
+              attr_accessor :a, :b, :c
+
+              def initialize(a, b, c)
+                @a = a
+                @b = b
+                @c = c
+              end
+            end
+          end
+
+          context 'when expose_nil option is not provided' do
+            it 'exposes nil attributes' do
+              subject.expose(:a)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is true' do
+            it 'exposes nil attributes' do
+              subject.expose(:a, expose_nil: true)
+              subject.expose(:b, expose_nil: true)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b, expose_nil: false)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(c: 'value')
+            end
+
+            it 'is only applied per attribute' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: 'value')
+            end
+
+            it 'raises an error when applied to multiple attribute exposures' do
+              expect { subject.expose(:a, :b, :c, expose_nil: false) }.to raise_error ArgumentError
+            end
+          end
+
+          context 'when expose_nil option is false and block passed' do
+            it 'does not expose if block returns nil' do
+              subject.expose(:a, expose_nil: false) do |_obj, _options|
+                nil
+              end
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: 'value')
+            end
+
+            it 'exposes is block returns a value' do
+              subject.expose(:a, expose_nil: false) do |_obj, _options|
+                100
+              end
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: 100, b: nil, c: 'value')
+            end
+          end
+        end
+
+        context 'when model is a hash' do
+          let(:model) { { a: a, b: b, c: c } }
+
+          context 'when expose_nil option is not provided' do
+            it 'exposes nil attributes' do
+              subject.expose(:a)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is true' do
+            it 'exposes nil attributes' do
+              subject.expose(:a, expose_nil: true)
+              subject.expose(:b, expose_nil: true)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b, expose_nil: false)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(c: 'value')
+            end
+
+            it 'is only applied per attribute' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: 'value')
+            end
+
+            it 'raises an error when applied to multiple attribute exposures' do
+              expect { subject.expose(:a, :b, :c, expose_nil: false) }.to raise_error ArgumentError
+            end
+          end
+        end
+
+        context 'with nested structures' do
+          let(:model) { { a: a, b: b, c: { d: nil, e: nil, f: { g: nil, h: nil } } } }
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c) do
+                subject.expose(:d, expose_nil: false)
+                subject.expose(:e)
+                subject.expose(:f) do
+                  subject.expose(:g, expose_nil: false)
+                  subject.expose(:h)
+                end
+              end
+
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: { e: nil, f: { h: nil } })
+            end
+          end
+        end
+      end
+
+      context 'with :default option' do
+        let(:a) { nil }
+        let(:b) { nil }
+        let(:c) { 'value' }
+
+        context 'when model is a PORO' do
+          let(:model) { Model.new(a, b, c) }
+
+          before do
+            stub_const 'Model', Class.new
+            Model.class_eval do
+              attr_accessor :a, :b, :c
+
+              def initialize(a, b, c)
+                @a = a
+                @b = b
+                @c = c
+              end
+            end
+          end
+
+          context 'when default option is not provided' do
+            it 'exposes attributes values' do
+              subject.expose(:a)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when default option is set' do
+            it 'exposes default values for attributes' do
+              subject.expose(:a, default: 'a')
+              subject.expose(:b, default: 'b')
+              subject.expose(:c, default: 'c')
+              expect(subject.represent(model).serializable_hash).to eq(a: 'a', b: 'b', c: 'value')
+            end
+          end
+
+          context 'when default option is set and block passed' do
+            it 'return default value if block returns nil' do
+              subject.expose(:a, default: 'a') do |_obj, _options|
+                nil
+              end
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: 'a', b: nil, c: 'value')
+            end
+
+            it 'return value from block if block returns a value' do
+              subject.expose(:a, default: 'a') do |_obj, _options|
+                100
+              end
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: 100, b: nil, c: 'value')
+            end
+          end
+        end
+
+        context 'when model is a hash' do
+          let(:model) { { a: a, b: b, c: c } }
+
+          context 'when expose_nil option is not provided' do
+            it 'exposes nil attributes' do
+              subject.expose(:a)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is true' do
+            it 'exposes nil attributes' do
+              subject.expose(:a, expose_nil: true)
+              subject.expose(:b, expose_nil: true)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b, expose_nil: false)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(c: 'value')
+            end
+
+            it 'is only applied per attribute' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: 'value')
+            end
+
+            it 'raises an error when applied to multiple attribute exposures' do
+              expect { subject.expose(:a, :b, :c, expose_nil: false) }.to raise_error ArgumentError
+            end
+          end
+        end
+
+        context 'with nested structures' do
+          let(:model) { { a: a, b: b, c: { d: nil, e: nil, f: { g: nil, h: nil } } } }
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c) do
+                subject.expose(:d, expose_nil: false)
+                subject.expose(:e)
+                subject.expose(:f) do
+                  subject.expose(:g, expose_nil: false)
+                  subject.expose(:h)
+                end
+              end
+
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: { e: nil, f: { h: nil } })
+            end
+          end
+        end
+      end
+
       context 'with a block' do
         it 'errors out if called with multiple attributes' do
           expect { subject.expose(:name, :email) { true } }.to raise_error ArgumentError
@@ -112,6 +384,53 @@ describe Grape::Entity do
           end
         end
 
+        describe 'blocks' do
+          class SomeObject
+            def method_without_args
+              'result'
+            end
+          end
+
+          describe 'with block passed in' do
+            specify do
+              subject.expose :that_method_without_args do |object|
+                object.method_without_args
+              end
+
+              object = SomeObject.new
+
+              value = subject.represent(object).value_for(:that_method_without_args)
+              expect(value).to eq('result')
+            end
+          end
+
+          context 'with block passed in via &' do
+            if RUBY_VERSION.start_with?('3')
+              specify do
+                subject.expose :that_method_without_args, &:method_without_args
+                subject.expose :method_without_args, as: :that_method_without_args_again
+
+                object = SomeObject.new
+                expect do
+                  subject.represent(object).value_for(:that_method_without_args)
+                end.to raise_error Grape::Entity::Deprecated
+
+                value2 = subject.represent(object).value_for(:that_method_without_args_again)
+                expect(value2).to eq('result')
+              end
+            else
+              specify do
+                subject.expose :that_method_without_args_again, &:method_without_args
+
+                object = SomeObject.new
+
+                value2 = subject.represent(object).value_for(:that_method_without_args_again)
+                expect(value2).to eq('result')
+              end
+            end
+          end
+        end
+
         context 'with no parameters passed to the block' do
           it 'adds a nested exposure' do
             subject.expose :awesome do
@@ -131,7 +450,7 @@ describe Grape::Entity do
             expect(another_nested).to_not be_nil
             expect(another_nested.using_class_name).to eq('Awesome')
             expect(moar_nested).to_not be_nil
-            expect(moar_nested.key).to eq(:weee)
+            expect(moar_nested.key(subject)).to eq(:weee)
           end
 
           it 'represents the exposure as a hash of its nested.root_exposures' do
@@ -324,6 +643,24 @@ describe Grape::Entity do
           expect(subject.represent({ name: 'bar' }, serializable: true)).to eq(email: nil, name: 'bar')
           expect(child_class.represent({ name: 'bar' }, serializable: true)).to eq(email: nil, name: 'foo')
         end
+
+        it 'not overrides exposure by default' do
+          subject.expose :name
+          child_class = Class.new(subject)
+          child_class.expose :name, as: :child_name
+
+          expect(subject.represent({ name: 'bar' }, serializable: true)).to eq(name: 'bar')
+          expect(child_class.represent({ name: 'bar' }, serializable: true)).to eq(name: 'bar', child_name: 'bar')
+        end
+
+        it 'overrides parent class exposure when option is specified' do
+          subject.expose :name
+          child_class = Class.new(subject)
+          child_class.expose :name, as: :child_name, override: true
+
+          expect(subject.represent({ name: 'bar' }, serializable: true)).to eq(name: 'bar')
+          expect(child_class.represent({ name: 'bar' }, serializable: true)).to eq(child_name: 'bar')
+        end
       end
 
       context 'register formatters' do
@@ -496,7 +833,7 @@ describe Grape::Entity do
         end
 
         exposure = subject.find_exposure(:awesome_thing)
-        expect(exposure.key).to eq :extra_smooth
+        expect(exposure.key(subject)).to eq :extra_smooth
       end
 
       it 'merges nested :if option' do
@@ -596,6 +933,34 @@ describe Grape::Entity do
         exposure = subject.find_exposure(:awesome_thing)
         expect(exposure.documentation).to eq(desc: 'Other description.')
       end
+
+      it 'propagates expose_nil option' do
+        subject.class_eval do
+          with_options(expose_nil: false) do
+            expose :awesome_thing
+          end
+        end
+
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.conditions[0].inversed?).to be true
+        expect(exposure.conditions[0].block.call(awesome_thing: nil)).to be true
+      end
+
+      it 'overrides nested :expose_nil option' do
+        subject.class_eval do
+          with_options(expose_nil: true) do
+            expose :awesome_thing, expose_nil: false
+            expose :other_awesome_thing
+          end
+        end
+
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.conditions[0].inversed?).to be true
+        expect(exposure.conditions[0].block.call(awesome_thing: nil)).to be true
+        # Conditions are only added for exposures that do not expose nil
+        exposure = subject.find_exposure(:other_awesome_thing)
+        expect(exposure.conditions[0]).to be_nil
+      end
     end
 
     describe '.represent' do
@@ -653,7 +1018,7 @@ describe Grape::Entity do
       context 'with specified fields' do
         it 'returns only specified fields with only option' do
           subject.expose(:id, :name, :phone)
-          representation = subject.represent(OpenStruct.new, only: [:id, :name], serializable: true)
+          representation = subject.represent(OpenStruct.new, only: %i[id name], serializable: true)
           expect(representation).to eq(id: nil, name: nil)
         end
 
@@ -666,7 +1031,7 @@ describe Grape::Entity do
         it 'returns only fields specified in the only option and not specified in the except option' do
           subject.expose(:id, :name, :phone)
           representation = subject.represent(OpenStruct.new,
-                                             only: [:name, :phone],
+                                             only: %i[name phone],
                                              except: [:phone], serializable: true)
           expect(representation).to eq(name: nil)
         end
@@ -736,7 +1101,7 @@ describe Grape::Entity do
           subject.expose(:id, :name, :phone)
           subject.expose(:user, using: user_entity)
 
-          representation = subject.represent(OpenStruct.new(user: {}), only: [:id, :name, { user: [:name, :email] }], serializable: true)
+          representation = subject.represent(OpenStruct.new(user: {}), only: [:id, :name, { user: %i[name email] }], serializable: true)
           expect(representation).to eq(id: nil, name: nil, user: { name: nil, email: nil })
         end
 
@@ -759,7 +1124,7 @@ describe Grape::Entity do
           subject.expose(:user, using: user_entity)
 
           representation = subject.represent(OpenStruct.new(user: {}),
-                                             only: [:id, :name, :phone, user: [:id, :name, :email]],
+                                             only: [:id, :name, :phone, { user: %i[id name email] }],
                                              except: [:phone, { user: [:id] }], serializable: true)
           expect(representation).to eq(id: nil, name: nil, user: { name: nil, email: nil })
         end
@@ -771,7 +1136,7 @@ describe Grape::Entity do
               subject.expose(:name)
             end
 
-            representation = subject.represent(OpenStruct.new, condition: true, only: [:id, :name], serializable: true)
+            representation = subject.represent(OpenStruct.new, condition: true, only: %i[id name], serializable: true)
             expect(representation).to eq(id: nil, name: nil)
           end
 
@@ -781,7 +1146,7 @@ describe Grape::Entity do
               subject.expose(:name, :mobile_phone)
             end
 
-            representation = subject.represent(OpenStruct.new, condition: true, except: [:phone, :mobile_phone], serializable: true)
+            representation = subject.represent(OpenStruct.new, condition: true, except: %i[phone mobile_phone], serializable: true)
             expect(representation).to eq(id: nil, name: nil)
           end
 
@@ -863,7 +1228,7 @@ describe Grape::Entity do
             subject.expose(:id)
             subject.expose(:name, as: :title)
 
-            representation = subject.represent(OpenStruct.new, condition: true, only: [:id, :title], serializable: true)
+            representation = subject.represent(OpenStruct.new, condition: true, only: %i[id title], serializable: true)
             expect(representation).to eq(id: nil, title: nil)
           end
 
@@ -890,10 +1255,22 @@ describe Grape::Entity do
             subject.expose(:nephew, using: nephew_entity)
 
             representation = subject.represent(OpenStruct.new(user: {}),
-                                               only: [:id, :name, :user], except: [:nephew], serializable: true)
+                                               only: %i[id name user], except: [:nephew], serializable: true)
             expect(representation).to eq(id: nil, name: nil, user: { id: nil, name: nil, email: nil })
           end
         end
+
+        context 'when NameError happens in a parameterized block_exposure' do
+          before do
+            subject.expose :raise_no_method_error do |_|
+              foo
+            end
+          end
+
+          it 'does not cause infinite loop' do
+            expect { subject.represent({}, serializable: true) }.to raise_error(NameError)
+          end
+        end
       end
     end
 
@@ -1178,6 +1555,18 @@ describe Grape::Entity do
         expect(res).to have_key :nonexistent_attribute
       end
 
+      it 'exposes attributes defined through module inclusion' do
+        module SharedAttributes
+          def a_value
+            3.14
+          end
+        end
+        fresh_class.include(SharedAttributes)
+        fresh_class.expose :a_value
+        res = fresh_class.new(model).serializable_hash
+        expect(res[:a_value]).to eq(3.14)
+      end
+
       it 'does not expose attributes that are generated by a block but have not passed criteria' do
         fresh_class.expose :nonexistent_attribute,
                            proc: ->(_, _) { 'I exist, but it is not yet my time to shine' },
@@ -1326,7 +1715,7 @@ describe Grape::Entity do
           end
 
           fresh_class.class_eval do
-            expose :characteristics, using: EntitySpec::NoPathCharacterEntity, attr_path: proc { nil }
+            expose :characteristics, using: EntitySpec::NoPathCharacterEntity, attr_path: proc {}
           end
 
           expect(subject.serializable_hash).to eq(
@@ -1341,8 +1730,8 @@ describe Grape::Entity do
         it 'allows to pass different :only and :except params using the same instance' do
           fresh_class.expose :a, :b, :c
           presenter = fresh_class.new(a: 1, b: 2, c: 3)
-          expect(presenter.serializable_hash(only: [:a, :b])).to eq(a: 1, b: 2)
-          expect(presenter.serializable_hash(only: [:b, :c])).to eq(b: 2, c: 3)
+          expect(presenter.serializable_hash(only: %i[a b])).to eq(a: 1, b: 2)
+          expect(presenter.serializable_hash(only: %i[b c])).to eq(b: 2, c: 3)
         end
       end
     end
@@ -1463,10 +1852,12 @@ describe Grape::Entity do
             end
           end
 
+          # rubocop:disable Lint/EmptyBlock
           fresh_class.class_eval do
             expose :first_friend, using: EntitySpec::FriendEntity do |_user, _opts|
             end
           end
+          # rubocop:enable Lint/EmptyBlock
 
           rep = subject.value_for(:first_friend)
           expect(rep).to be_kind_of EntitySpec::FriendEntity
@@ -1765,39 +2156,5 @@ describe Grape::Entity do
         end
       end
     end
-
-    describe Grape::Entity::Options do
-      module EntitySpec
-        class Crystalline
-          attr_accessor :prop1, :prop2
-
-          def initialize
-            @prop1 = 'value1'
-            @prop2 = 'value2'
-          end
-        end
-
-        class CrystallineEntity < Grape::Entity
-          expose :prop1, if: ->(_, options) { options.fetch(:signal) }
-          expose :prop2, if: ->(_, options) { options.fetch(:beam, 'destructive') == 'destructive' }
-        end
-      end
-
-      context '#fetch' do
-        it 'without passing in a required option raises KeyError' do
-          expect { EntitySpec::CrystallineEntity.represent(EntitySpec::Crystalline.new).as_json }.to raise_error KeyError
-        end
-
-        it 'passing in a required option will expose the values' do
-          crystalline_entity = EntitySpec::CrystallineEntity.represent(EntitySpec::Crystalline.new, signal: true)
-          expect(crystalline_entity.as_json).to eq(prop1: 'value1', prop2: 'value2')
-        end
-
-        it 'with an option that is not default will not expose that value' do
-          crystalline_entity = EntitySpec::CrystallineEntity.represent(EntitySpec::Crystalline.new, signal: true, beam: 'intermittent')
-          expect(crystalline_entity.as_json).to eq(prop1: 'value1')
-        end
-      end
-    end
   end
 end

data/spec/grape_entity/exposure/nesting_exposure/nested_exposures_spec.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Entity::Exposure::NestingExposure::NestedExposures do
   subject(:nested_exposures) { described_class.new([]) }
 
-  describe '#deep_complex_nesting?' do
+  describe '#deep_complex_nesting?(entity)' do
     it 'is reset when additional exposure is added' do
       subject << Grape::Entity::Exposure.new(:x, {})
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-      subject.deep_complex_nesting?
+      subject.deep_complex_nesting?(subject)
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to_not be_nil
       subject << Grape::Entity::Exposure.new(:y, {})
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
@@ -16,7 +18,7 @@ describe Grape::Entity::Exposure::NestingExposure::NestedExposures do
     it 'is reset when exposure is deleted' do
       subject << Grape::Entity::Exposure.new(:x, {})
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-      subject.deep_complex_nesting?
+      subject.deep_complex_nesting?(subject)
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to_not be_nil
       subject.delete_by(:x)
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
@@ -25,7 +27,7 @@ describe Grape::Entity::Exposure::NestingExposure::NestedExposures do
     it 'is reset when exposures are cleared' do
       subject << Grape::Entity::Exposure.new(:x, {})
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-      subject.deep_complex_nesting?
+      subject.deep_complex_nesting?(subject)
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to_not be_nil
       subject.clear
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil

data/spec/grape_entity/exposure/represent_exposure_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Entity::Exposure::RepresentExposure do
@@ -10,11 +12,11 @@ describe Grape::Entity::Exposure::RepresentExposure do
     let(:subexposure)      { double(:subexposure) }
 
     it 'sets using_class_name' do
-      expect { subject }.to change { exposure.using_class_name }.to(using_class_name)
+      expect { subject }.to change(exposure, :using_class_name).to(using_class_name)
     end
 
     it 'sets subexposure' do
-      expect { subject }.to change { exposure.subexposure }.to(subexposure)
+      expect { subject }.to change(exposure, :subexposure).to(subexposure)
     end
 
     context 'when using_class is set' do
@@ -23,7 +25,7 @@ describe Grape::Entity::Exposure::RepresentExposure do
       end
 
       it 'resets using_class' do
-        expect { subject }.to change { exposure.using_class }
+        expect { subject }.to change(exposure, :using_class)
       end
     end
   end

data/spec/grape_entity/exposure_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Entity::Exposure do
@@ -24,12 +26,22 @@ describe Grape::Entity::Exposure do
   describe '#key' do
     it 'returns the attribute if no :as is set' do
       fresh_class.expose :name
-      expect(subject.key).to eq :name
+      expect(subject.key(entity)).to eq :name
     end
 
     it 'returns the :as alias if one exists' do
       fresh_class.expose :name, as: :nombre
-      expect(subject.key).to eq :nombre
+      expect(subject.key(entity)).to eq :nombre
+    end
+
+    it 'returns the result if :as is a proc' do
+      fresh_class.expose :name, as: proc { object.name.reverse }
+      expect(subject.key(entity)).to eq(model.name.reverse)
+    end
+
+    it 'returns the result if :as is a lambda' do
+      fresh_class.expose :name, as: ->(obj, _opts) { obj.name.reverse }
+      expect(subject.key(entity)).to eq(model.name.reverse)
     end
   end