yaks 0.4.2 → 0.4.3

data/spec/unit/yaks/default_policy/derive_mapper_from_object_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::DefaultPolicy, '#derive_mapper_from_object' do
+  subject(:policy) { described_class.new(options) }
+
+  let(:options) { {} }
+
+  context 'for a single instance' do
+    it 'should derive it by name' do
+      expect(policy.derive_mapper_from_object(Soy.new)).to be SoyMapper
+    end
+
+    context 'given a namespace' do
+      let(:options) { {namespace: MyMappers} }
+
+      it 'should look inside the namespace' do
+        expect(policy.derive_mapper_from_object(Soy.new)).to be MyMappers::SoyMapper
+      end
+    end
+  end
+
+  context 'for array-like objects' do
+    context 'given an empty array' do
+      it 'should return the vanilla CollectionMapper' do
+        expect(policy.derive_mapper_from_object([])).to be Yaks::CollectionMapper
+      end
+    end
+
+    it 'should find the mapper based on naming' do
+      expect(policy.derive_mapper_from_object([Soy.new])).to be SoyCollectionMapper
+    end
+
+    context 'if no collection mapper with a similar name is defined' do
+      let(:options) { {namespace: Namespace} }
+
+      it 'should look for a CollectionMapper in the namespace' do
+        expect(policy.derive_mapper_from_object([Wheat.new])).to be(
+          Namespace::CollectionMapper
+        )
+      end
+    end
+  end
+
+  context 'for a model class inside a module' do
+    let(:options) { {namespace: Namespace} }
+
+    it 'should take the non-qualified classname, and search the mapper namespace with that' do
+      expect(policy.derive_mapper_from_object(Namespace::Nested::Rye.new)).to be(
+        Namespace::RyeMapper
+      )
+    end
+
+    it 'should take the non-qualified classname when looking for a collection mapper' do
+      expect(policy.derive_mapper_from_object([Namespace::Nested::Rye.new])).to be(
+        Namespace::RyeCollectionMapper
+      )
+    end
+  end
+
+  context 'when trying to lookup CollectionMapper results in something other than an NameError' do
+    let(:options) { { namespace: DislikesCollectionMapper } }
+
+    it 'should propagate the error' do
+      expect {
+        policy.derive_mapper_from_object([])
+      }.to raise_error
+    end
+  end
+
+  context 'when trying to lookup a specific collection mapper results in something other than an NameError' do
+    let(:options) { { namespace: DislikesOtherMappers } }
+
+    it 'should propagate the error' do
+      expect {
+        policy.derive_mapper_from_object([Namespace::Nested::Rye.new])
+      }.to raise_error
+    end
+  end
+
+end

data/spec/unit/yaks/default_policy_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::DefaultPolicy do
+  subject(:policy) { described_class.new( options ) }
+
+  let(:options) { {} }
+  let(:association) { Yaks::Mapper::HasMany.new(name: 'shoes', collectionMapper: nil) }
+
+  describe '#initialize' do
+    it 'should work without arguments' do
+      expect(described_class.new.options).to eql described_class::DEFAULTS
+    end
+
+    let(:options) { {foo: :bar} }
+
+    it 'should merge default and given options' do
+      expect(policy.options.values_at(:namespace, :foo)).to eql [Kernel, :bar]
+    end
+  end
+
+  describe '#derive_type_from_mapper_class' do
+    specify do
+      expect(
+        policy.derive_type_from_mapper_class(Namespace::RyeMapper)
+      ).to eql 'rye'
+    end
+  end
+
+  describe '#derive_mapper_from_association' do
+    let(:options) { { namespace: Namespace } }
+
+    it 'should derive using the singular association name, and look inside the namespace' do
+      expect(policy.derive_mapper_from_association(association)).to be Namespace::ShoeMapper
+    end
+  end
+
+  describe '#derive_rel_from_association' do
+    it 'should expand the rel based on the association name' do
+      expect(policy.derive_rel_from_association(association)).to eql 'rel:shoes'
+    end
+  end
+
+  describe '#expand_rel' do
+    let(:options) { { rel_template: 'http://foo/{?rel}' } }
+    it 'should expand the given template' do
+      expect(policy.expand_rel('rockets')).to eql 'http://foo/?rel=rockets'
+    end
+  end
+
+end

data/spec/unit/yaks/{serializer → format}/hal_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Yaks::Serializer::Hal do
+RSpec.describe Yaks::Format::Hal do
   include_context 'plant collection resource'
 
   subject { Yaks::Primitivize.create.call(described_class.new.call(resource)) }

data/spec/unit/yaks/format/json_api_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+# Mainly tested through the acceptance tests, here covering a few specific edge cases
+RSpec.describe Yaks::Format::JsonApi do
+  let(:format) { Yaks::Format::JsonApi.new }
+
+  context 'with no subresources' do
+    let(:resource) { Yaks::Resource.new(type: 'wizard', attributes: {foo: :bar}) }
+
+    it 'should not include a "linked" key' do
+      expect(format.call(resource)).to eql(
+        {'wizards' => [{foo: :bar}]}
+      )
+    end
+  end
+
+  context 'with both a "href" attribute and a self link' do
+      let(:resource) {
+        Yaks::Resource.new(
+        type: 'wizard',
+        attributes: {
+          href: '/the/href'
+        },
+        links: [
+          Yaks::Resource::Link.new(:self, '/the/self/link', {})
+        ]
+      )
+    }
+
+    it 'should give preference to the href attribute' do
+      expect(format.call(resource)).to eql(
+        {'wizards' => [
+            {
+              href: '/the/href'
+            }
+          ]
+        }
+      )
+    end
+  end
+
+end

data/spec/unit/yaks/format_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Format do
+  describe '.by_name' do
+    specify { expect(Yaks::Format.by_name(:hal)).to eql Yaks::Format::Hal }
+    specify { expect(Yaks::Format.by_name(:json_api)).to eql Yaks::Format::JsonApi }
+  end
+
+  describe '.by_mime_type' do
+    specify { expect(Yaks::Format.by_mime_type('application/hal+json')).to eql Yaks::Format::Hal }
+  end
+end

data/spec/unit/yaks/fp/hash_updatable_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+
+RSpec.describe Yaks::FP::HashUpdatable do
+  let(:klz) do
+    Class.new do
+      include Equalizer.new(:aa, :bb, :cc)
+      include Yaks::FP::HashUpdatable.new(:aa, :bb, :cc)
+
+      attr_reader :aa, :bb, :cc
+      private :aa
+
+      def initialize(opts)
+        @aa, @bb, @cc = opts.values_at(:aa, :bb, :cc)
+      end
+    end
+  end
+
+  it 'should only update the selected fields' do
+    expect(klz.new(aa: 1, bb: 2, cc: 3).update(bb: 7, cc: 9)).to eq klz.new(aa: 1, bb: 7, cc: 9)
+  end
+end

data/spec/unit/yaks/fp/updatable_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+
+RSpec.describe Yaks::FP::Updatable do
+  let(:klz) do
+    Class.new do
+      include Equalizer.new(:aa, :bb, :cc)
+      include Yaks::FP::Updatable.new(:aa, :bb, :cc)
+
+      attr_reader :aa, :bb, :cc
+      private :aa
+
+      def initialize(aa, bb, cc)
+        @aa, @bb, @cc = aa, bb, cc
+      end
+    end
+  end
+
+  it 'should only updated the selected fields' do
+    expect(klz.new(1,2,3).update(bb: 7, cc: 9)).to eq klz.new(1,7,9)
+  end
+end

data/spec/unit/yaks/mapper/association_mapper_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Mapper::AssociationMapper do
+  include_context 'yaks context'
+
+  subject(:association_mapper) { described_class.new(parent_mapper, association, yaks_context) }
+
+  let(:parent_mapper_class) { Yaks::Mapper }
+  let(:parent_mapper)       { parent_mapper_class.new(yaks_context) }
+
+  fake(:association) { Yaks::Mapper::Association }
+
+  its(:policy) { should be policy }
+
+  let(:mapper_stack) { [:bottom_mapper] }
+
+  describe '#call' do
+    context 'when the association should be rendered as link' do
+      before do
+        stub(association).render_as_link?(parent_mapper) { true }
+        stub(association).map_rel(policy) { 'rels:the_rel' }
+        stub(association).href { 'http://this/is_where_the_associated_thing_can_be_found' }
+      end
+
+      it 'should render a link' do
+        expect(association_mapper.call(Yaks::Resource.new)).to eql Yaks::Resource.new(
+          links: [
+            Yaks::Resource::Link.new(
+              'rels:the_rel',
+              'http://this/is_where_the_associated_thing_can_be_found', {}
+            )
+          ]
+        )
+      end
+    end
+
+    context 'when the association should be rendered as a subresource' do
+      before do
+        stub(association).render_as_link?(parent_mapper) { false }
+        stub(association).map_rel(policy) { 'rels:the_rel' }
+        stub(association).name { :the_name }
+        stub(association).map_resource(:the_object, association_mapper.context) { :the_resource }
+
+        stub(parent_mapper).load_association(:the_name) { :the_object }
+      end
+
+      it 'should render a link' do
+        expect(association_mapper.call(Yaks::Resource.new)).to eql Yaks::Resource.new(
+          subresources: {
+            'rels:the_rel' => :the_resource
+          }
+        )
+      end
+
+      it 'should add the mapper to the mapper_stack' do
+        expect(association_mapper.context[:mapper_stack]).to eql [:bottom_mapper, parent_mapper]
+      end
+    end
+  end
+end

data/spec/unit/yaks/mapper/association_spec.rb

@@ -1,79 +1,134 @@
 require 'spec_helper'
 
 RSpec.describe Yaks::Mapper::Association do
-  include Yaks::FP
+  include_context 'yaks context'
 
-  let(:name)              { :shoes       }
-  let(:mapper)            { Yaks::Mapper }
+  subject(:association) do
+    described_class.new(
+      name: name,
+      mapper: mapper,
+      rel: rel,
+      href: href,
+      link_if: link_if
+    )
+  end
+
+  let(:name)              { :shoes          }
+  let(:mapper)            { Yaks::Mapper    }
   let(:rel)               { Yaks::Undefined }
-  let(:collection_mapper) { Yaks::Undefined }
-  let(:parent_mapper)     { Yaks::Undefined }
-  let(:map_resource)      { ->(obj, policy) {} }
-  let(:lookup)            { ->(*) {} }
-  let(:policy)            { Yaks::DefaultPolicy.new }
-  let(:context)           { { policy: policy, env: {} } }
+  let(:href)              { Yaks::Undefined }
+  let(:link_if)           { Yaks::Undefined }
 
-  its(:name) { should equal :shoes }
+  its(:name)         { should equal :shoes }
+  its(:child_mapper) { should equal Yaks::Mapper }
 
-  subject(:association) do
-    described_class.new(name, mapper, rel, collection_mapper)
+  context 'with a minimal constructor' do
+    subject(:association) { described_class.new(name: :foo) }
+
+    its(:name)         { should be :foo }
+    its(:child_mapper) { should be Yaks::Undefined }
+    its(:rel)          { should be Yaks::Undefined }
+    its(:href)         { should be Yaks::Undefined }
+    its(:link_if)      { should be Yaks::Undefined }
   end
 
-  describe '#create_subresource' do
-    subject(:resource_pair) do
-      association.create_subresource(parent_mapper, lookup, context)
+  let(:parent_mapper_class) { Yaks::Mapper }
+  let(:parent_mapper)       { parent_mapper_class.new(yaks_context) }
+
+  describe '#add_to_resource' do
+    let(:object) { fake(:shoes => []) }
+    let(:rel)    { 'rel:shoes' }
+    before do
+      parent_mapper.call(object)
     end
 
-    context 'with a rel specified' do
-      let(:rel) { 'http://api.com/rels/shoes' }
+    it 'should delegate to AssociationMapper' do
+      expect(association.add_to_resource(Yaks::Resource.new, parent_mapper, yaks_context)).to eql Yaks::Resource.new(subresources: {'rel:shoes' => nil} )
+    end
+  end
 
-      it 'should use the specified rel' do
-        expect(resource_pair[0]).to eql 'http://api.com/rels/shoes'
+  describe '#render_as_link?' do
+    let(:href)     { '/foo/{bar}/baz' }
+    let(:link_if)  { -> { env.fetch('env_entry') == 123 } }
+    let(:rack_env) { { 'env_entry' => 123 } }
+
+    let(:render_as_link?) { association.render_as_link?(parent_mapper) }
+
+    context 'when evaluating to true' do
+      it 'should resolve :link_if in the context of the mapper' do
+        expect(render_as_link?).to be true
       end
     end
 
-    context 'without a rel specified' do
-      it 'should infer a rel based on policy' do
-        expect(policy)
-          .to receive(:derive_rel_from_association)
-          .with(parent_mapper, association)
-          .and_return('http://api.com/rel/derived')
+    context 'when evaluating to false' do
+      let(:rack_env) { { 'env_entry' => 0 } }
+
+      it 'should resolve :link_if in the context of the mapper' do
+        expect(render_as_link?).to be false
+      end
+    end
+
+    context 'with an Undefined href' do
+      let(:href) { Yaks::Undefined }
 
-        expect(resource_pair[0]).to eql 'http://api.com/rel/derived'
+      it 'should return falsey' do
+        expect(render_as_link?).to be_falsey
       end
     end
 
-    let(:lookup) { { shoes: 'unmapped resource' } }
+    context 'with an Undefined link_if' do
+      let(:link_if) { Yaks::Undefined }
 
-    it 'should delegate to the map_resource method, to be overridden in child classes' do
-      expect(association)
-        .to receive(:map_resource)
-        .with('unmapped resource', context)
-        .and_return('mapped resource')
+      it 'should return falsey' do
+        expect(render_as_link?).to be_falsey
+      end
+    end
+  end
+
+  describe '#map_rel' do
+    let(:association_rel) { association.map_rel(policy) }
+
+    context 'with a rel specified' do
+      let(:rel) { 'http://api.com/rels/shoes' }
 
-      expect(resource_pair[1]).to eql 'mapped resource'
+      it 'should use the specified rel' do
+        expect(association_rel).to eql 'http://api.com/rels/shoes'
+      end
+    end
+
+    context 'without a rel specified' do
+      before do
+        stub(policy).derive_rel_from_association(association) {
+          'http://api.com/rel/derived'
+        }
+      end
+
+      it 'should infer a rel based on policy' do
+        expect(association_rel).to eql 'http://api.com/rel/derived'
+      end
     end
   end
 
-  describe '#association_mapper' do
+  describe '#resolve_association_mapper' do
     context 'with a specified mapper' do
       let(:mapper) { :a_specific_mapper_class }
 
       it 'should return the mapper' do
-        expect(association.association_mapper(nil)).to equal :a_specific_mapper_class
+        expect(association.resolve_association_mapper(nil)).to equal :a_specific_mapper_class
       end
     end
 
     context 'with the mapper undefined' do
       let(:mapper) { Yaks::Undefined }
 
-      it 'should derive a mapper based on policy' do
-        expect(policy)
-          .to receive(:derive_mapper_from_association)
-          .with(association)
-          .and_return(:a_derived_mapper_class)
+      before do
+        stub(policy).derive_mapper_from_association(association) {
+          :a_derived_mapper_class
+        }
+      end
 
-        expect(association.association_mapper(policy)).to equal :a_derived_mapper_class
+      it 'should derive a mapper based on policy' do
+        expect(association.resolve_association_mapper(policy)).to equal :a_derived_mapper_class
       end
     end
   end

data/spec/unit/yaks/mapper/attribute_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Mapper::Attribute do
+  include_context 'yaks context'
+
+  subject(:attribute) { described_class.new(:the_name) }
+  fake(:mapper)
+
+  its(:name) { should be :the_name }
+
+  before do
+    stub(mapper).load_attribute(:the_name) { 123 }
+  end
+
+  it 'should add itself to a resource based on a lookup' do
+    expect(attribute.add_to_resource(Yaks::Resource.new, mapper , yaks_context)).to eql(
+      Yaks::Resource.new(attributes: { :the_name => 123 })
+    )
+  end
+end

data/spec/unit/yaks/mapper/class_methods_spec.rb

@@ -1,28 +1,67 @@
 require 'spec_helper'
 
 RSpec.describe Yaks::Mapper::ClassMethods do
-  subject { Class.new { extend Yaks::Mapper::ClassMethods } }
-
-  describe 'attributes' do
-    before do
-      subject.attributes(:foo, :bar)
+  subject(:mapper_class) do
+    Class.new do
+      extend Yaks::Mapper::ClassMethods
+      attributes :foo, :bar
+      link :some_rel, 'http://some_link'
+      has_one :thing
+      has_many :thingies
     end
+  end
 
+  describe 'attributes' do
     it 'should allow setting them' do
-      expect( subject.attributes ).to eq [:foo, :bar]
+      expect( mapper_class.attributes ).to eq [
+        Yaks::Mapper::Attribute.new(:foo),
+        Yaks::Mapper::Attribute.new(:bar)
+      ]
     end
 
     describe 'with inheritance' do
-      let(:child) { Class.new(subject) }
-      before { child.attributes(:baz) }
+      let(:child_class) do
+        Class.new(mapper_class) do
+          attributes :baz
+        end
+      end
+
+      let(:grandchild_class) do
+        Class.new(child_class)
+      end
 
       it 'should inherit attributes from the parent' do
-        expect(child.attributes).to eq [:foo, :bar, :baz]
+        expect(child_class.attributes).to eq [
+          Yaks::Mapper::Attribute.new(:foo),
+          Yaks::Mapper::Attribute.new(:bar),
+          Yaks::Mapper::Attribute.new(:baz)
+        ]
+      end
+
+      it 'should create a valid config' do
+        expect(grandchild_class.config).to be_a Yaks::Mapper::Config
       end
 
       it 'should not alter the parent' do
-        expect(subject.attributes).to eq [:foo, :bar]
+        expect(mapper_class.attributes).to eq [
+          Yaks::Mapper::Attribute.new(:foo),
+          Yaks::Mapper::Attribute.new(:bar),
+        ]
       end
     end
   end
+
+  it 'should register links' do
+    expect(mapper_class.config.links).to eq [
+      Yaks::Mapper::Link.new(:some_rel, 'http://some_link', {})
+    ]
+  end
+
+  it 'should register associations' do
+    expect(mapper_class.config.associations).to eq [
+      Yaks::Mapper::HasOne.new(name: :thing),
+      Yaks::Mapper::HasMany.new(name: :thingies)
+    ]
+  end
+
 end