yaks 0.4.4 → 0.5.0

data/spec/support/deep_eql.rb

@@ -39,19 +39,18 @@ module Matchers
       end.join
     end
 
-    def failure_message(message)
+    def add_failure_message(message)
       diffs << "at %s, %s" % [stack_as_jsonpath, message]
       @result = false
     end
 
     def compare(key)
-#require 'pry' ; binding.pry
       push key
       if target[key] != expectation[key]
         if [Hash, Array].any?{|klz| target[key].is_a? klz }
           recurse(target[key], expectation[key])
         else
-          failure_message begin
+          add_failure_message begin
                             if expectation[key].class == target[key].class
                               "expected #{expectation[key].inspect}, got #{target[key].inspect}"
                             else
@@ -72,13 +71,19 @@ module Matchers
       when Hash
         if target.is_a?(Hash)
           if target.class != expectation.class # e.g. HashWithIndifferentAccess
-            failure_message("expected #{expectation.class}, got #{target.class}")
+            add_failure_message("expected #{expectation.class}, got #{target.class}")
+          end
+          (expectation.keys - target.keys).each do |key|
+            add_failure_message "Expected key #{key}"
+          end
+          (target.keys - expectation.keys).each do |key|
+            add_failure_message "Unexpected key #{key}"
           end
           (target.keys | expectation.keys).each do |key|
             compare key
           end
         else
-          failure_message("expected Hash got #{@target.inspect}")
+          add_failure_message("expected Hash got #{@target.inspect}")
         end
 
       when Array
@@ -87,12 +92,12 @@ module Matchers
             compare idx
           end
         else
-          failure_message("expected Array got #{@target.inspect}")
+          add_failure_message("expected Array got #{@target.inspect}")
         end
 
       else
         if target != expectation
-          failure_message("expected #{expectation.inspect}, got #{@target.inspect}")
+          add_failure_message("expected #{expectation.inspect}, got #{@target.inspect}")
         end
       end
 
@@ -102,10 +107,12 @@ module Matchers
     def failure_message_for_should
       diffs.join("\n")
     end
+    alias failure_message failure_message_for_should
 
     def failure_message_for_should_not
       "expected #{@target.inspect} not to be in deep_eql with #{@expectation.inspect}"
     end
+    alias failure_message_when_negated failure_message_for_should_not
   end
 end
 

data/spec/support/pet_mapper.rb

@@ -1,5 +1,3 @@
 class PetMapper < Yaks::Mapper
   attributes :id, :name, :species
-
-  #link :collection, '/api/pets/{id*}'
 end

data/spec/unit/yaks/collection_mapper_spec.rb

@@ -10,8 +10,7 @@ RSpec.describe Yaks::CollectionMapper do
     { item_mapper: item_mapper,
       policy: policy,
       env: {},
-      mapper_stack: []
-    }
+      mapper_stack: [] }
   }
 
   let(:collection) { [] }
@@ -33,6 +32,10 @@ RSpec.describe Yaks::CollectionMapper do
     let(:item_mapper) { PetMapper }
 
     it 'should map the members' do
+      stub(policy).derive_mapper_from_object(any_args) do
+        raise ":item_mapper was specified explicitly, should not be derived from object"
+      end
+
       expect(mapper.call(collection)).to eql Yaks::CollectionResource.new(
         type: 'pet',
         links: [],
@@ -140,4 +143,23 @@ RSpec.describe Yaks::CollectionMapper do
     end
   end
 
+  context 'with an empty collection' do
+
+    context 'without an item_mapper specified' do
+      let(:context) { Yaks::Util.slice_hash(super(), :policy, :env) }
+
+      it 'should use a rel of "collection"' do
+        expect(mapper.([]).collection_rel).to eq 'collection'
+      end
+    end
+
+    context 'with an item_mapper specified' do
+      let(:context) { Yaks::Util.slice_hash(super(), :policy, :env, :item_mapper) }
+
+      it 'should derive the collection rel from the item mapper' do
+        expect(mapper.([]).collection_rel).to eq 'rel:the_types'
+      end
+    end
+
+  end
 end

data/spec/unit/yaks/config/dsl_spec.rb

@@ -43,7 +43,7 @@ RSpec.describe Yaks::Config::DSL do
 
   describe '#format_options' do
     configure { format_options :hal, singular_link: [:self] }
-    specify   { expect(yaks_config.format_options[:hal].should eq(singular_link: [:self])) }
+    specify   { expect(yaks_config.format_options[:hal]).to eq(singular_link: [:self]) }
   end
 
   describe '#default_format' do
@@ -61,6 +61,11 @@ RSpec.describe Yaks::Config::DSL do
     specify   { expect(yaks_config.policy_options[:rel_template]).to eql 'rels:{rel}' }
   end
 
+  describe '#json_serializer' do
+    configure { json_serializer { |i| "foo #{i}" } }
+    specify   { expect(yaks_config.serializers[:json].call(7)).to eql 'foo 7' }
+  end
+
   describe '#mapper_namespace' do
     configure { mapper_namespace RSpec }
     specify   { expect(yaks_config.policy_options[:namespace]).to eql RSpec }
@@ -79,13 +84,4 @@ RSpec.describe Yaks::Config::DSL do
     specify   { expect(yaks_config.primitivize.call({:abc => Foo.new('hello')})).to eql 'abc' => 'hello' }
   end
 
-  describe '#after' do
-    configure do
-      after {|x| x + 1}
-      after {|x| x + 10}
-    end
-    it 'should register the block' do
-      expect(yaks_config.steps.inject(0) {|memo, step| step.call(memo)}).to be 11
-    end
-  end
 end

data/spec/unit/yaks/config_spec.rb

@@ -7,57 +7,63 @@ RSpec.describe Yaks::Config do
     subject(:config) { described_class.new(&blk) }
   end
 
-  context 'defaults' do
-    configure {}
-
-    its(:default_format) { should equal :hal }
-    its(:policy_class)   { should < Yaks::DefaultPolicy }
-
-    it 'should have empty format options' do
-      expect(config.options_for_format(:hal)).to eql({})
-    end
-  end
-
-  context 'with a default format' do
-    configure do
-      default_format :json_api
+  describe '#initialize' do
+    context 'defaults' do
+      configure {}
+
+      its(:default_format) { should equal :hal }
+      its(:policy_class)   { should < Yaks::DefaultPolicy }
+      its(:primitivize)    { should be_a Yaks::Primitivize }
+      its(:serializers)    { should eql({})  }
+      its(:hooks)          { should eql([])  }
+
+      it 'should have empty format options' do
+        expect(config.format_options[:hal]).to eql({})
+      end
     end
 
-    its(:default_format) { should equal :json_api }
-  end
+    context 'with a default format' do
+      configure do
+        default_format :json_api
+      end
 
-  context 'with a custom policy class' do
-    MyPolicy = Struct.new(:options)
-    configure do
-      policy MyPolicy
+      its(:default_format) { should equal :json_api }
     end
 
-    its(:policy_class) { should equal MyPolicy }
-    its(:policy)       { should be_a  MyPolicy }
-  end
+    context 'with a custom policy class' do
+      MyPolicy = Struct.new(:options)
+      configure do
+        policy MyPolicy
+      end
 
-  context 'with a rel template' do
-    configure do
-      rel_template 'http://rel/foo'
+      its(:policy_class) { should equal MyPolicy }
+      its(:policy)       { should be_a  MyPolicy }
     end
 
-    its(:policy_options) { should eql(rel_template: 'http://rel/foo') }
-  end
+    context 'with a rel template' do
+      configure do
+        rel_template 'http://rel/foo'
+      end
 
-  context 'with format options' do
-    configure do
-      format_options :hal, plural_links: [:self, :profile]
+      its(:policy_options) { should eql(rel_template: 'http://rel/foo') }
     end
 
-    specify do
-      expect(config.options_for_format(:hal)).to eql(plural_links: [:self, :profile])
+    context 'with format options' do
+      configure do
+        format_options :hal, plural_links: [:self, :profile]
+      end
+
+      specify do
+        expect(config.format_options[:hal]).to eql(plural_links: [:self, :profile])
+      end
     end
   end
 
-  describe '#serialize' do
+  describe '#call' do
     configure do
       rel_template 'http://api.mysuperfriends.com/{rel}'
       format_options :hal, plural_links: [:copyright]
+      skip :serialize
     end
 
     specify do
@@ -65,69 +71,4 @@ RSpec.describe Yaks::Config do
     end
   end
 
-  describe '#mapper_namespace' do
-    module MyMappers
-      class PetMapper < Yaks::Mapper
-      end
-    end
-
-    configure do
-      mapper_namespace MyMappers
-    end
-
-    specify do
-      expect(config.policy.derive_mapper_from_object(boingboing)).to eql(MyMappers::PetMapper)
-    end
-  end
-
-  describe '#map_to_primitive' do
-    class TheMapper < Yaks::Mapper
-      attributes :a_date
-    end
-
-    TheModel = Struct.new(:a_date)
-
-    configure do
-      map_to_primitive Date do |object|
-        object.iso8601
-      end
-    end
-
-    let(:model) {
-      TheModel.new(Date.new(2014, 5, 6))
-    }
-
-    specify do
-      expect(config.serialize(model, mapper: TheMapper)).to eq({"a_date"=>"2014-05-06"})
-    end
-  end
-
-  describe '#format_class' do
-    configure do
-      default_format :collection_json
-    end
-
-    let(:rack_env) {
-      { 'HTTP_ACCEPT' => 'application/hal+json;q=0.8, application/vnd.api+json' }
-    }
-
-    it 'should fall back to the default when no HTTP_ACCEPT key is present' do
-      expect(config.format_class({}, {})).to equal Yaks::Format::CollectionJson
-    end
-
-    it 'should detect format based on accept header' do
-      rack_env = { 'HTTP_ACCEPT' => 'application/hal+json;q=0.8, application/vnd.api+json' }
-      expect(config.format_class({}, rack_env)).to equal Yaks::Format::JsonApi
-    end
-
-    it 'should know to pick the best match' do
-      rack_env = { 'HTTP_ACCEPT' => 'application/hal+json;q=0.8, application/vnd.api+json;q=0.7' }
-      expect(config.format_class({}, rack_env)).to equal Yaks::Format::Hal
-    end
-
-    it 'should fall back to the default when no mime type is recognized' do
-      rack_env = { 'HTTP_ACCEPT' => 'text/html, application/json' }
-      expect(config.format_class({}, rack_env)).to equal Yaks::Format::CollectionJson
-    end
-  end
 end

data/spec/unit/yaks/default_policy_spec.rb

@@ -26,6 +26,20 @@ RSpec.describe Yaks::DefaultPolicy do
     end
   end
 
+  describe '#derive_type_from_collection' do
+    specify do
+      expect(
+        policy.derive_type_from_collection([Soy.new])
+      ).to eql 'soy'
+    end
+
+    specify do
+      expect(
+        policy.derive_type_from_collection([])
+      ).to be_nil
+    end
+  end
+
   describe '#derive_mapper_from_association' do
     let(:options) { { namespace: Namespace } }
 
@@ -47,4 +61,10 @@ RSpec.describe Yaks::DefaultPolicy do
     end
   end
 
+  describe '#serializer_for_format' do
+    specify {
+      expect(policy.serializer_for_format(Yaks::Format::JsonAPI).call('foo' => [1,2])).to eql "{\n  \"foo\": [\n    1,\n    2\n  ]\n}"
+    }
+  end
+
 end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Format::CollectionJson do
+  context 'with the plant collection resource' do
+    include_context 'plant collection resource'
+
+    subject { Yaks::Primitivize.create.call(described_class.new.call(resource)) }
+
+    it { should deep_eql(load_json_fixture('plant_collection.collection')) }
+  end
+
+  context 'with a link without title' do
+    let(:resource) {
+      Yaks::Resource.new(
+        attributes: {foo: 'fooval', bar: 'barval'},
+        links: [Yaks::Resource::Link.new('the_rel', 'the_uri', {})]
+      )
+    }
+
+    subject {
+      Yaks::Primitivize.create.call(described_class.new.call(resource))
+    }
+
+    it 'should not render a name' do
+      should deep_eql(
+        "collection" => {
+          "version" => "1.0",
+          "items" => [
+            {
+              "data" => [
+                { "name"=>"foo", "value"=>"fooval" },
+                { "name"=>"bar", "value"=>"barval" }
+              ],
+              "links" => [{"rel"=>"the_rel", "href"=>"the_uri"}]
+            }
+          ]
+        }
+      )
+    end
+  end
+end

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

@@ -1,9 +1,44 @@
 require 'spec_helper'
 
 RSpec.describe Yaks::Format::Hal do
-  include_context 'plant collection resource'
+  context 'with the plant collection resource' do
+    include_context 'plant collection resource'
 
-  subject { Yaks::Primitivize.create.call(described_class.new.call(resource)) }
+    subject { Yaks::Primitivize.create.call(described_class.new.call(resource)) }
 
-  it { should eq(load_json_fixture('hal_plant_collection')) }
+    it { should deep_eql(load_json_fixture('plant_collection.hal')) }
+  end
+
+  context 'with multiple links on the same rel' do
+    let(:format) {
+      described_class.new(:plural_links => 'my_plural_rel')
+    }
+
+    let(:resource) {
+      Yaks::Resource.new(
+        attributes: {foo: 'fooval', bar: 'barval'},
+        links: [
+          Yaks::Resource::Link.new('my_plural_rel', 'the_uri1', {}),
+          Yaks::Resource::Link.new('my_plural_rel', 'the_uri2', {})
+        ]
+      )
+    }
+
+    subject {
+      Yaks::Primitivize.create.call(format.call(resource))
+    }
+
+    it 'should render both links' do
+      should deep_eql(
+        'foo' => 'fooval',
+        'bar' => 'barval',
+        '_links' => {
+          "my_plural_rel" => [
+            {"href"=>"the_uri1"},
+            {"href"=>"the_uri2"}
+          ]
+        }
+      )
+    end
+  end
 end

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

@@ -1,8 +1,8 @@
 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 }
+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}) }

data/spec/unit/yaks/format_spec.rb

@@ -2,11 +2,36 @@ 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 }
+    specify do
+      expect(Yaks::Format.by_name(:hal)).to eql Yaks::Format::Hal
+    end
+    specify do
+      expect(Yaks::Format.by_name(:json_api)).to eql Yaks::Format::JsonAPI
+    end
   end
 
   describe '.by_mime_type' do
-    specify { expect(Yaks::Format.by_mime_type('application/hal+json')).to eql Yaks::Format::Hal }
+    specify do
+      expect(Yaks::Format.by_mime_type('application/hal+json')).to eql Yaks::Format::Hal
+    end
+  end
+
+  describe '.by_accept_header' do
+    specify do
+      expect(Yaks::Format.by_accept_header('application/hal+json;q=0.8, application/vnd.api+json')).to eql Yaks::Format::JsonAPI
+    end
+    specify do
+      expect(Yaks::Format.by_accept_header('application/hal+json;q=0.8, application/vnd.api+json;q=0.7')).to eql Yaks::Format::Hal
+    end
+  end
+
+  describe '.mime_types' do
+    specify do
+      expect(Yaks::Format.mime_types).to eql(
+        collection_json: "application/vnd.collection+json",
+        hal: "application/hal+json",
+        json_api: "application/vnd.api+json"
+      )
+    end
   end
 end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::FP::Callable do
+  it 'should delegate to_proc to method(:call)' do
+    obj = Class.new do
+      include Yaks::FP::Callable
+
+      def call(x) ; x * x ; end
+    end.new
+
+    expect([1,2,3].map(&obj)).to eql [1,4,9]
+  end
+end