yaks 0.4.4 → 0.5.0

data/spec/unit/yaks/mapper_spec.rb

@@ -12,192 +12,292 @@ RSpec.describe Yaks::Mapper do
 
   its(:env) { should equal rack_env }
 
-  context 'with attributes' do
-    before do
-      mapper_class.attributes :foo, :bar
-    end
-
-    it 'should make the configured attributes available on the instance' do
-      expect(mapper.attributes).to eq [
-        Yaks::Mapper::Attribute.new(:foo),
-        Yaks::Mapper::Attribute.new(:bar)
-      ]
-    end
-
-    it 'should load them from the model' do
-      expect(resource.attributes).to eq(foo: 'hello', bar: 'world')
-    end
-
-    context 'with attribute filtering' do
+  describe '#call' do
+    context 'with attributes' do
       before do
-        mapper_class.class_eval do
-          def attributes
-            super.reject {|attr| attr.name == :foo}
-          end
-        end
+        mapper_class.attributes :foo, :bar
       end
 
-      it 'should only map the non-filtered attributes' do
-        expect(resource.attributes).to eq(:bar => 'world')
+      it 'should make the configured attributes available on the instance' do
+        expect(mapper.attributes).to eq [
+          Yaks::Mapper::Attribute.new(:foo),
+          Yaks::Mapper::Attribute.new(:bar)
+        ]
       end
-    end
-  end
 
-  context 'with links' do
-    before do
-      mapper_class.link :profile, 'http://foo/bar'
-    end
+      it 'should load them from the model' do
+        expect(resource.attributes).to eq(foo: 'hello', bar: 'world')
+      end
 
-    it 'should map the link' do
-      expect(resource.links).to eq [
-        Yaks::Resource::Link.new(:profile, 'http://foo/bar', {})
-      ]
-    end
+      context 'with attribute filtering' do
+        before do
+          mapper_class.class_eval do
+            def attributes
+              super.reject {|attr| attr.name == :foo}
+            end
+          end
+        end
 
-    it 'should use the link in the resource' do
-      expect(resource.links).to include Yaks::Resource::Link.new(:profile, 'http://foo/bar', {})
+        it 'should only map the non-filtered attributes' do
+          expect(resource.attributes).to eq(:bar => 'world')
+        end
+      end
     end
 
-    context 'with the same link rel defined multiple times' do
+    context 'with links' do
       before do
-        mapper_class.class_eval do
-          link(:self, 'http://foo/bam')
-          link(:self, 'http://foo/baz')
-          link(:self, 'http://foo/baq')
-        end
+        mapper_class.link :profile, 'http://foo/bar'
       end
 
-      it 'should map all the links' do
+      it 'should map the link' do
         expect(resource.links).to eq [
-          Yaks::Resource::Link.new(:profile, 'http://foo/bar', {}),
-          Yaks::Resource::Link.new(:self, 'http://foo/bam', {}),
-          Yaks::Resource::Link.new(:self, 'http://foo/baz', {}),
-          Yaks::Resource::Link.new(:self, 'http://foo/baq', {})
+          Yaks::Resource::Link.new(:profile, 'http://foo/bar', {})
         ]
       end
-    end
-  end
 
-  context 'with subresources' do
-    let(:widget)   { fake(type: 'super_widget') }
-    let(:instance) { fake(widget: widget) }
-    let(:widget_mapper) { Class.new(Yaks::Mapper) { type 'widget' } }
-    fake(:policy) { Yaks::DefaultPolicy }
-
-    describe 'has_one' do
-      let(:has_one_opts) do
-        { mapper: widget_mapper,
-          rel: 'http://foo.bar/rels/widgets' }
+      it 'should use the link in the resource' do
+        expect(resource.links).to include Yaks::Resource::Link.new(:profile, 'http://foo/bar', {})
       end
 
-      before do
-        widget_mapper.attributes :type
-        mapper_class.has_one(:widget, has_one_opts)
-      end
-
-
-      it 'should have the subresource in the resource' do
-        expect(resource.subresources).to eq("http://foo.bar/rels/widgets" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"}))
-      end
+      context 'with the same link rel defined multiple times' do
+        before do
+          mapper_class.class_eval do
+            link(:self, 'http://foo/bam')
+            link(:self, 'http://foo/baz')
+            link(:self, 'http://foo/baq')
+          end
+        end
 
-      context 'with explicit mapper and rel' do
-        it 'should delegate to the given mapper' do
-          expect(resource.subresources).to eq(
-            "http://foo.bar/rels/widgets" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"})
-          )
+        it 'should map all the links' do
+          expect(resource.links).to eq [
+            Yaks::Resource::Link.new(:profile, 'http://foo/bar', {}),
+            Yaks::Resource::Link.new(:self, 'http://foo/bam', {}),
+            Yaks::Resource::Link.new(:self, 'http://foo/baz', {}),
+            Yaks::Resource::Link.new(:self, 'http://foo/baq', {})
+          ]
         end
       end
+    end
+
+    context 'with subresources' do
+      let(:widget)   { fake(type: 'super_widget') }
+      let(:instance) { fake(widget: widget) }
+      let(:widget_mapper) { Class.new(Yaks::Mapper) { type 'widget' } }
+      fake(:policy) { Yaks::DefaultPolicy }
 
-      context 'with unspecified mapper' do
+      describe 'has_one' do
         let(:has_one_opts) do
-          { rel: 'http://foo.bar/rels/widgets' }
+          { mapper: widget_mapper,
+            rel: 'http://foo.bar/rels/widgets' }
         end
 
         before do
-          stub(policy).derive_mapper_from_association(mapper.associations.first) do
-            widget_mapper
-          end
+          widget_mapper.attributes :type
+          mapper_class.has_one(:widget, has_one_opts)
         end
 
-        it 'should derive the mapper based on policy' do
-          expect(resource.subresources).to eq(
-            "http://foo.bar/rels/widgets" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"})
-          )
-        end
-      end
 
-      context 'with unspecified rel' do
-        let(:has_one_opts) do
-          { mapper: widget_mapper }
+        it 'should have the subresource in the resource' do
+          expect(resource.subresources).to eq("http://foo.bar/rels/widgets" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"}))
         end
 
-        before do
-          stub(policy).derive_rel_from_association(mapper.associations.first) do
-            'http://rel/rel'
+        context 'with explicit mapper and rel' do
+          it 'should delegate to the given mapper' do
+            expect(resource.subresources).to eq(
+              "http://foo.bar/rels/widgets" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"})
+            )
           end
         end
 
-        it 'should derive the rel based on policy' do
-          expect(resource.subresources).to eq(
-            "http://rel/rel" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"})
-          )
+        context 'with unspecified mapper' do
+          let(:has_one_opts) do
+            { rel: 'http://foo.bar/rels/widgets' }
+          end
+
+          before do
+            stub(policy).derive_mapper_from_association(mapper.associations.first) do
+              widget_mapper
+            end
+          end
+
+          it 'should derive the mapper based on policy' do
+            expect(resource.subresources).to eq(
+              "http://foo.bar/rels/widgets" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"})
+            )
+          end
         end
-      end
 
-      context 'with the association filtered out' do
-        before do
-          mapper_class.class_eval do
-            def associations
-              []
+        context 'with unspecified rel' do
+          let(:has_one_opts) do
+            { mapper: widget_mapper }
+          end
+
+          before do
+            stub(policy).derive_rel_from_association(mapper.associations.first) do
+              'http://rel/rel'
             end
           end
+
+          it 'should derive the rel based on policy' do
+            expect(resource.subresources).to eq(
+              "http://rel/rel" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"})
+            )
+          end
         end
 
-        it 'should not map the resource' do
-          expect(resource.subresources).to eq({})
+        context 'with the association filtered out' do
+          before do
+            mapper_class.class_eval do
+              def associations
+                []
+              end
+            end
+          end
+
+          it 'should not map the resource' do
+            expect(resource.subresources).to eq({})
+          end
         end
       end
     end
-  end
 
-  context 'when the mapper implements a method with the attribute name' do
-    before do
-      mapper_class.class_eval do
-        attributes :fooattr, :bar
+    context 'when the mapper implements a method with the attribute name' do
+      before do
+        mapper_class.class_eval do
+          attributes :fooattr, :bar
 
-        def fooattr
-          "#{object.foo} my friend"
+          def fooattr
+            "#{object.foo} my friend"
+          end
         end
       end
+
+      it 'should get the attribute from the mapper' do
+        expect(resource.attributes).to eq(fooattr: 'hello my friend', bar: 'world')
+      end
     end
 
-    it 'should get the attribute from the mapper' do
-      expect(resource.attributes).to eq(fooattr: 'hello my friend', bar: 'world')
+    context 'with a nil subject' do
+      it 'should return a NullResource when the subject is nil' do
+        expect(mapper.call(nil)).to be_a Yaks::NullResource
+      end
+    end
+
+    context 'with a link generated by a method that returns nil' do
+      before do
+        mapper_class.class_eval do
+          attributes :id
+          link :bar_link, :link_generating_method
+
+          def link_generating_method
+          end
+        end
+      end
+
+      it 'should not render the link' do
+        expect(mapper.call(fake(id: 123))).to eql Yaks::Resource.new(
+          type: 'foo',
+          attributes: {id: 123}
+        )
+      end
     end
   end
 
-  context 'with a nil subject' do
-    it 'should return a NullResource when the subject is nil' do
-      expect(mapper.call(nil)).to be_a Yaks::NullResource
+  describe '.mapper_name' do
+    context 'with a type configured' do
+      it 'should use the type' do
+        expect(mapper_class.mapper_name(policy)).to eql 'foo'
+      end
+    end
+
+    context 'without a type configured' do
+      let(:mapper_class) { PetMapper }
+
+      it 'should infer the type from the name' do
+        expect(mapper_class.mapper_name(policy)).to eql 'pet'
+      end
     end
   end
 
-  context 'with a link generated by a method that returns nil' do
-    before do
-      mapper_class.class_eval do
-        attributes :id
-        link :bar_link, :link_generating_method
+  describe '#mapper_name' do
+    context 'with a type configured' do
+      it 'should use the type' do
+        expect(mapper.mapper_name).to eql 'foo'
+      end
+    end
+
+    context 'without a type configured' do
+      let(:mapper_class) { PetMapper }
 
-        def link_generating_method
+      it 'should infer the type from the name' do
+        expect(mapper.mapper_name).to eql 'pet'
+      end
+    end
+  end
+
+  describe '#load_attribute' do
+    context 'with the attribute defined as a method on the mapper' do
+      it 'should call the local implementation' do
+        def mapper.foo
+          14
         end
+
+        expect(mapper.load_attribute(:foo)).to eql 14
+      end
+    end
+
+    context 'without a mapper method with the attribute name' do
+      it 'should call the method on the object being mapped' do
+        mapper.call(instance) # set @object
+        expect(mapper.load_attribute(:foo)).to eql 'hello'
       end
     end
+  end
+
+  describe '#map_attributes' do
+    let(:attribute) { fake('Attribute') }
+
+    it 'should receive a context' do
+      stub(attribute).add_to_resource(any_args) {|r,_,_| Yaks::Resource.new}
+
+      mapper.config.attributes[0..-1] = [attribute]
+      mapper.call(instance)
+
+      expect(attribute).to have_received.add_to_resource(any(Yaks::Resource), mapper, yaks_context)
+    end
+  end
+
+  describe '#map_links' do
+    let(:link) { fake('Link') }
+
+    it 'should receive a context' do
+      stub(link).add_to_resource(any_args) {|r,_,_| Yaks::Resource.new}
+
+      mapper.config.links[0..-1] = [link]
+      mapper.call(instance)
+
+      expect(link).to have_received.add_to_resource(any(Yaks::Resource), mapper, yaks_context)
+    end
+  end
+
+  describe '#map_subresources' do
+    let(:association) { fake('Association') }
+
+    it 'should receive a context' do
+      stub(association).add_to_resource(any_args) {|r,_,_| Yaks::Resource.new}
+
+      mapper.config.associations[0..-1] = [association]
+      mapper.call(instance)
+
+      expect(association).to have_received.add_to_resource(any(Yaks::Resource), mapper, yaks_context)
+    end
+  end
+
+  describe '#mapper_stack' do
+    let(:yaks_context) { super().merge(mapper_stack: [:foo]) }
 
-    it 'should not render the link' do
-      expect(mapper.call(fake(id: 123))).to eql Yaks::Resource.new(
-        type: 'foo',
-        attributes: {id: 123}
-      )
+    it 'should delegate to context' do
+      expect(mapper.mapper_stack).to eql [:foo]
     end
   end
 end

data/spec/unit/yaks/resource/link_spec.rb

@@ -4,13 +4,12 @@ RSpec.describe Yaks::Resource::Link do
   subject(:link) { described_class.new(rel, uri, options) }
   let(:rel)      { :foo_rel }
   let(:uri)      { 'http://api.example.org/rel/foo' }
-  let(:options)  { {name: 'jimmy', title: 'mr. spectacular' } }
+  let(:options)  { { title: 'mr. spectacular' } }
 
   its(:rel)     { should eql :foo_rel }
   its(:uri)     { should eql 'http://api.example.org/rel/foo' }
-  its(:options) { should eql(name: 'jimmy', title: 'mr. spectacular') }
+  its(:options) { should eql(title: 'mr. spectacular') }
 
-  its(:name)       { should eql('jimmy') }
   its(:title)      { should eql('mr. spectacular') }
   its(:templated?) { should be false }
 

data/spec/unit/yaks/resource_spec.rb

@@ -90,4 +90,19 @@ RSpec.describe Yaks::Resource do
       )
     end
   end
+
+  describe '#self_link' do
+    let(:init_opts) {
+      { links:
+        [
+          Yaks::Resource::Link.new(:self, 'foo', {}),
+          Yaks::Resource::Link.new(:self, 'bar', {}),
+          Yaks::Resource::Link.new(:profile, 'baz', {})
+        ]
+      }
+    }
+    it 'should return the last self link' do
+      expect(resource.self_link).to eql Yaks::Resource::Link.new(:self, 'bar', {})
+    end
+  end
 end