hyperclient 0.4.0 → 0.5.0

data/lib/hyperclient/link_collection.rb

@@ -1,5 +1,6 @@
 require 'hyperclient/collection'
 require 'hyperclient/link'
+require 'hyperclient/curie'
 
 module Hyperclient
   # Public: A wrapper class to easily acces the links in a  Resource.
@@ -12,30 +13,54 @@ module Hyperclient
   class LinkCollection < Collection
     # Public: Initializes a LinkCollection.
     #
-    # collection  - The Hash with the links.
+    # collection - The Hash with the links.
+    # curies - Link curies.
     # entry_point - The EntryPoint object to inject the configuration.
-    def initialize(collection, entry_point)
-      raise "Invalid response for LinkCollection. The response was: #{collection.inspect}" if collection && !collection.respond_to?(:collect)
+    def initialize(collection, curies, entry_point)
+      fail "Invalid response for LinkCollection. The response was: #{collection.inspect}" if collection && !collection.respond_to?(:collect)
 
-      @collection = (collection || {}).inject({}) do |hash, (name, link)|
-        hash.update(name => build_link(link, entry_point))
+      @curies = (curies || {}).reduce({}) do |hash, curie_hash|
+        curie = build_curie(curie_hash, entry_point)
+        hash.update(curie.name => curie)
+      end
+
+      @collection = (collection || {}).reduce({}) do |hash, (name, link)|
+        hash.update(name => build_link(name, link, @curies, entry_point))
       end
     end
 
     private
+
     # Internal: Creates links from the response hash.
     #
     # link_or_links - A Hash or an Array of hashes with the links to build.
-    # entry_point   - The EntryPoint object to inject the configuration.
+    # entry_point - The EntryPoint object to inject the configuration.
+    # curies - Optional curies for templated links.
     #
     # Returns a Link or an array of Links when given an Array.
-    def build_link(link_or_links, entry_point)
+    def build_link(name, link_or_links, curies, entry_point)
       return unless link_or_links
-      return Link.new(link_or_links, entry_point) unless link_or_links.respond_to?(:to_ary)
-
-      link_or_links.collect do |link|
-        build_link(link, entry_point)
+      if link_or_links.respond_to?(:to_ary)
+        link_or_links.map do |link|
+          build_link(name, link, curies, entry_point)
+        end
+      elsif (curie_parts = /(?<ns>[^:]+):(?<short_name>.+)/.match(name))
+        curie = curies[curie_parts[:ns]]
+        link_or_links['href'] = curie.expand(link_or_links['href']) if curie
+        Link.new(name, link_or_links, entry_point)
+      else
+        Link.new(name, link_or_links, entry_point)
       end
     end
+
+    # Internal: Creates a curie from the response hash.
+    #
+    # curie_hash - A Hash with the curie.
+    # entry_point - The EntryPoint object to inject the configuration.
+    #
+    # Returns a Link or an array of Links when given an Array.
+    def build_curie(curie_hash, entry_point)
+      Curie.new(curie_hash, entry_point)
+    end
   end
 end

data/lib/hyperclient/resource.rb

@@ -10,53 +10,84 @@ module Hyperclient
     extend Forwardable
 
     # Public: Returns the attributes of the Resource as Attributes.
-    attr_reader :attributes
+    attr_reader :_attributes
 
     # Public: Returns the links of the Resource as a LinkCollection.
-    attr_reader :links
+    attr_reader :_links
 
     # Public: Returns the embedded resource of the Resource as a
     # ResourceCollection.
-    attr_reader :embedded
+    attr_reader :_embedded
 
     # Public: Returns the response object for the HTTP request that created this
     # resource, if one exists.
-    attr_reader :response
+    attr_reader :_response
 
     # Public: Delegate all HTTP methods (get, post, put, delete, options and
     # head) to its self link.
-    def_delegators :self_link, :get, :post, :put, :delete, :options, :head
+    def_delegators :_self_link, :_get, :_post, :_put, :_delete, :_options, :_head
 
     # Public: Initializes a Resource.
     #
     # representation - The hash with the HAL representation of the Resource.
     # entry_point    - The EntryPoint object to inject the configutation.
-    def initialize(representation, entry_point, response=nil)
+    def initialize(representation, entry_point, response = nil)
       representation = representation ? representation.dup : {}
-      @links       = LinkCollection.new(representation['_links'], entry_point)
-      @embedded    = ResourceCollection.new(representation['_embedded'], entry_point)
-      @attributes  = Attributes.new(representation)
-      @entry_point = entry_point
-      @response    = response
+      links = representation['_links'] || {}
+      @_links       = LinkCollection.new(links, links['curies'], entry_point)
+      @_embedded    = ResourceCollection.new(representation['_embedded'], entry_point)
+      @_attributes  = Attributes.new(representation)
+      @_entry_point = entry_point
+      @_response    = response
     end
 
     def inspect
-      "#<#{self.class.name} self_link:#{self_link.inspect} attributes:#{@attributes.inspect}>"
+      "#<#{self.class.name} self_link:#{_self_link.inspect} attributes:#{@_attributes.inspect}>"
     end
 
-    def success?
-      response && response.success?
+    def _success?
+      _response && _response.success?
     end
 
-    def status
-      response && response.status
+    def _status
+      _response && _response.status
+    end
+
+    def [](name)
+      send(name) if respond_to?(name)
     end
 
     private
+
     # Internal: Returns the self Link of the Resource. Used to handle the HTTP
     # methods.
-    def self_link
-      @links['self']
+    def _self_link
+      @_links['self']
+    end
+
+    # Internal: Delegate the method to various elements of the resource.
+    #
+    # This allows `api.posts` instead of `api.links.posts.resource`
+    # as well as api.posts(id: 1) assuming posts is a link.
+    def method_missing(method, *args, &block)
+      if args.any? && args.first.is_a?(Hash)
+        _links.send(method, [], &block)._expand(*args)
+      else
+        [:_attributes, :_embedded, :_links].each do |target|
+          target = send(target)
+          return target.send(method, *args, &block) if target.respond_to?(method.to_s)
+        end
+        super
+      end
+    end
+
+    # Internal: Accessory method to allow the resource respond to
+    # methods that will hit method_missing.
+    def respond_to_missing?(method, include_private = false)
+      [:_attributes, :_embedded, :_links].each do |target|
+        return true if send(target).respond_to?(method, include_private)
+      end
+      false
     end
   end
 end

data/lib/hyperclient/resource_collection.rb

@@ -18,12 +18,13 @@ module Hyperclient
     #
     def initialize(collection, entry_point)
       @entry_point = entry_point
-      @collection = (collection || {}).inject({}) do |hash, (name, resource)|
+      @collection = (collection || {}).reduce({}) do |hash, (name, resource)|
         hash.update(name => build_resource(resource))
       end
     end
 
     private
+
     def build_resource(representation)
       return representation.map(&method(:build_resource)) if representation.is_a?(Array)
 

data/lib/hyperclient/version.rb

@@ -1,3 +1,3 @@
 module Hyperclient
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/test/fixtures/element.json

@@ -15,7 +15,18 @@
                 "href": "/gizmos/2"
             }
         ],
-        "null_link": null
+        "curies" : [
+            {
+              "name": "image",
+              "href": "/images/{rel}",
+              "templated": true
+            }
+        ],
+        "null_link": null,
+        "image:thumbnail": {
+          "href": "thumbnails/{version}.jpg",
+          "templated": true
+        }
     },
     "title": "Real World ASP.NET MVC3",
     "description": "In this advanced, somewhat-opinionated production you'll get your very own startup off the ground using ASP.NET MVC 3...",

data/test/hyperclient/attributes_test.rb

@@ -4,7 +4,7 @@ require 'hyperclient/attributes'
 module Hyperclient
   describe Attributes do
     let(:representation) do
-      JSON.parse( File.read('test/fixtures/element.json'))
+      JSON.parse(File.read('test/fixtures/element.json'))
     end
 
     let(:attributes) do
@@ -24,7 +24,7 @@ module Hyperclient
       attributes.permitted.must_equal true
 
       attributes.must_respond_to :title
-      attributes.title.must_equal "Real World ASP.NET MVC3"
+      attributes.title.must_equal 'Real World ASP.NET MVC3'
     end
 
     # Underscores should be allowed per http://tools.ietf.org/html/draft-kelly-json-hal#appendix-B.4

data/test/hyperclient/collection_test.rb

@@ -4,7 +4,7 @@ require 'hyperclient/resource'
 module Hyperclient
   describe Collection do
     let(:representation) do
-      JSON.parse( File.read('test/fixtures/element.json'))
+      JSON.parse(File.read('test/fixtures/element.json'))
     end
 
     let(:collection) do
@@ -28,11 +28,11 @@ module Hyperclient
     end
 
     it 'acts as enumerable' do
-      names = collection.map do |name, value|
+      names = collection.map do |name, _value|
         name
       end
 
-      names.must_equal ['_links', 'title', 'description', 'permitted', '_hidden_attribute', '_embedded']
+      names.must_equal %w(_links title description permitted _hidden_attribute _embedded)
     end
 
     describe '#to_hash' do
@@ -53,16 +53,16 @@ module Hyperclient
 
     describe '#fetch' do
       it 'returns the value for keys that exist' do
-        collection.fetch('title').must_equal "Real World ASP.NET MVC3"
+        collection.fetch('title').must_equal 'Real World ASP.NET MVC3'
       end
 
       it 'raises an error for missing keys' do
-        Proc.new { collection.fetch('missing key') }.must_raise KeyError
+        proc { collection.fetch('missing key') }.must_raise KeyError
       end
 
       describe 'with a default value' do
         it 'returns the value for keys that exist' do
-          collection.fetch('title', 'default').must_equal "Real World ASP.NET MVC3"
+          collection.fetch('title', 'default').must_equal 'Real World ASP.NET MVC3'
         end
 
         it 'returns the default value for missing keys' do
@@ -73,4 +73,3 @@ module Hyperclient
 
   end
 end
-

data/test/hyperclient/curie_test.rb

@@ -0,0 +1,34 @@
+require_relative '../test_helper'
+require 'hyperclient/curie'
+require 'hyperclient/entry_point'
+
+module Hyperclient
+  describe Curie do
+    let(:entry_point) do
+      EntryPoint.new('http://api.example.org/')
+    end
+
+    describe 'templated?' do
+      it 'returns true if the curie is templated' do
+        curie = Curie.new({ 'name' => 'image', 'templated' => true }, entry_point)
+
+        curie.templated?.must_equal true
+      end
+
+      it 'returns false if the curie is not templated' do
+        curie = Curie.new({ 'name' => 'image' }, entry_point)
+
+        curie.templated?.must_equal false
+      end
+    end
+
+    let(:curie) do
+      Curie.new({ 'name' => 'image', 'href' => '/images/{?rel}', 'templated' => true }, entry_point)
+    end
+    describe '_name' do
+      it 'returns curie name' do
+        curie.name.must_equal 'image'
+      end
+    end
+  end
+end

data/test/hyperclient/entry_point_test.rb

@@ -19,6 +19,7 @@ module Hyperclient
 
       it 'creates a Faraday connection with the default block' do
         handlers = entry_point.connection.builder.handlers
+        handlers.must_include FaradayMiddleware::FollowRedirects
         handlers.must_include FaradayMiddleware::EncodeJson
         handlers.must_include FaradayMiddleware::ParseJson
         handlers.must_include Faraday::Adapter::NetHttp
@@ -27,8 +28,8 @@ module Hyperclient
 
     describe 'initialize' do
       it 'sets a Link with the entry point url' do
-        entry_point.url.must_equal 'http://my.api.org'
+        entry_point._url.must_equal 'http://my.api.org'
       end
     end
   end
-end
+end

data/test/hyperclient/link_collection_test.rb

@@ -3,14 +3,14 @@ require 'hyperclient/link_collection'
 
 module Hyperclient
   describe LinkCollection do
-    let(:entry_point) { stub('Entry point', config: {base_uri: '/'}) }
+    let(:entry_point) { stub('Entry point', config: { base_uri: '/' }) }
 
     let(:representation) do
-      JSON.parse( File.read('test/fixtures/element.json'))
+      JSON.parse(File.read('test/fixtures/element.json'))
     end
 
     let(:links) do
-      LinkCollection.new(representation['_links'], entry_point)
+      LinkCollection.new(representation['_links'], representation['_links']['curies'], entry_point)
     end
 
     it 'is a collection' do
@@ -30,7 +30,28 @@ module Hyperclient
       links['gizmos'].must_be_kind_of Array
     end
 
-    describe "array of links" do
+    describe 'plain link' do
+      let(:plain_link) { links.self }
+      it 'must be correct' do
+        plain_link._url.must_equal '/productions/1'
+      end
+    end
+
+    describe 'templated link' do
+      let(:templated_link) { links.filter }
+      it 'must expand' do
+        templated_link._expand(filter: 'gizmos')._url.must_equal '/productions/1?categories=gizmos'
+      end
+    end
+
+    describe 'curied link collection' do
+      let(:curied_link) { links['image:thumbnail'] }
+      it 'must expand' do
+        curied_link._expand(version: 'small')._url.must_equal '/images/thumbnails/small.jpg'
+      end
+    end
+
+    describe 'array of links' do
       let(:gizmos) { links.gizmos }
 
       it 'should have 2 items' do
@@ -44,7 +65,7 @@ module Hyperclient
       end
     end
 
-    describe "null link value" do
+    describe 'null link value' do
       let(:null_link) { links.null_link }
       it 'must be nil' do
         null_link.must_be_nil

data/test/hyperclient/link_test.rb

@@ -10,190 +10,196 @@ module Hyperclient
 
     %w(type deprecation name profile title hreflang).each do |prop|
       describe prop do
-        it "returns the property value" do
-          link = Link.new({prop => 'value'}, entry_point)
-          link.send(prop).must_equal 'value'
+        it 'returns the property value' do
+          link = Link.new('key', { prop => 'value' }, entry_point)
+          link.send("_#{prop}").must_equal 'value'
         end
 
         it 'returns nil if the property is not present' do
-          link = Link.new({}, entry_point)
-          link.send(prop).must_equal nil
+          link = Link.new('key', {}, entry_point)
+          link.send("_#{prop}").must_equal nil
         end
       end
     end
 
-    describe 'templated?' do
+    describe '_templated?' do
       it 'returns true if the link is templated' do
-        link = Link.new({'templated' => true}, entry_point)
+        link = Link.new('key', { 'templated' => true }, entry_point)
 
-        link.templated?.must_equal true
+        link._templated?.must_equal true
       end
 
       it 'returns false if the link is not templated' do
-        link = Link.new({}, entry_point)
+        link = Link.new('key', {}, entry_point)
 
-        link.templated?.must_equal false
+        link._templated?.must_equal false
       end
     end
 
-    describe 'variables' do
+    describe '_variables' do
       it 'returns a list of required variables' do
-        link = Link.new({'href' => '/orders{?id,owner}', 'templated' => true}, entry_point)
+        link = Link.new('key', { 'href' => '/orders{?id,owner}', 'templated' => true }, entry_point)
 
-        link.variables.must_equal ['id', 'owner']
+        link._variables.must_equal %w(id owner)
       end
 
       it 'returns an empty array for untemplated links' do
-        link = Link.new({'href' => '/orders'}, entry_point)
+        link = Link.new('key', { 'href' => '/orders' }, entry_point)
 
-        link.variables.must_equal []
+        link._variables.must_equal []
       end
     end
 
-    describe 'expand' do
+    describe '_expand' do
       it 'buils a Link with the templated URI representation' do
-        link = Link.new({'href' => '/orders{?id}', 'templated' => true}, entry_point)
+        link = Link.new('key', { 'href' => '/orders{?id}', 'templated' => true }, entry_point)
 
-        Link.expects(:new).with(anything, entry_point, {id: '1'})
-        link.expand(id: '1')
+        Link.expects(:new).with('key', anything, entry_point, id: '1')
+        link._expand(id: '1')
       end
 
       it 'raises if no uri variables are given' do
-        link = Link.new({'href' => '/orders{?id}', 'templated' => true}, entry_point)
-        lambda { link.expand }.must_raise ArgumentError
+        link = Link.new('key', { 'href' => '/orders{?id}', 'templated' => true }, entry_point)
+        lambda { link._expand }.must_raise ArgumentError
       end
     end
 
-    describe 'url' do
+    describe '_url' do
       it 'raises when missing required uri_variables' do
-        link = Link.new({'href' => '/orders{?id}', 'templated' => true}, entry_point)
+        link = Link.new('key', { 'href' => '/orders{?id}', 'templated' => true }, entry_point)
 
-        lambda { link.url }.must_raise MissingURITemplateVariablesException
+        lambda { link._url }.must_raise MissingURITemplateVariablesException
       end
 
       it 'expands an uri template with variables' do
-        link = Link.new({'href' => '/orders{?id}', 'templated' => true}, entry_point, {id: 1})
+        link = Link.new('key', { 'href' => '/orders{?id}', 'templated' => true }, entry_point, id: 1)
 
-        link.url.must_equal '/orders?id=1'
+        link._url.must_equal '/orders?id=1'
       end
 
       it 'returns the link when no uri template' do
-        link = Link.new({'href' => '/orders'}, entry_point)
-        link.url.must_equal '/orders'
+        link = Link.new('key', { 'href' => '/orders' }, entry_point)
+        link._url.must_equal '/orders'
+      end
+
+      it 'aliases to_s to _url' do
+        link = Link.new('key', { 'href' => '/orders{?id}', 'templated' => true }, entry_point, id: 1)
+
+        link.to_s.must_equal '/orders?id=1'
       end
     end
 
-    describe 'resource' do
+    describe '_resource' do
       it 'builds a resource with the link href representation' do
         mock_response = mock(body: {}, success?: true)
 
         Resource.expects(:new).with({}, entry_point, mock_response)
 
-        link = Link.new({'href' => '/'}, entry_point)
-        link.expects(:get).returns(mock_response)
+        link = Link.new('key', { 'href' => '/' }, entry_point)
+        link.expects(:_get).returns(mock_response)
 
-        link.resource
+        link._resource
       end
 
-      it "has an empty body when the response fails" do
+      it 'has an empty body when the response fails' do
         mock_response = mock(success?: false)
 
         Resource.expects(:new).with(nil, entry_point, mock_response)
 
-        link = Link.new({'href' => '/'}, entry_point)
-        link.expects(:get).returns(mock_response)
+        link = Link.new('key', { 'href' => '/' }, entry_point)
+        link.expects(:_get).returns(mock_response)
 
-        link.resource
+        link._resource
       end
     end
 
-    describe 'connection' do
+    describe '_connection' do
       it 'returns the entry point connection' do
-        Link.new({}, entry_point).connection.must_equal entry_point.connection
+        Link.new('key', {}, entry_point)._connection.must_equal entry_point.connection
       end
     end
 
     describe 'get' do
       it 'sends a GET request with the link url' do
-        link = Link.new({'href' => '/productions/1'}, entry_point)
+        link = Link.new('key', { 'href' => '/productions/1' }, entry_point)
 
         entry_point.connection.expects(:get).with('/productions/1')
-        link.get.inspect
+        link._get.inspect
       end
     end
 
-    describe 'options' do
+    describe '_options' do
       it 'sends a OPTIONS request with the link url' do
-        link = Link.new({'href' => '/productions/1'}, entry_point)
+        link = Link.new('key', { 'href' => '/productions/1' }, entry_point)
 
         entry_point.connection.expects(:run_request).with(:options, '/productions/1', nil, nil)
-        link.options.inspect
+        link._options.inspect
       end
     end
 
-    describe 'head' do
+    describe '_head' do
       it 'sends a HEAD request with the link url' do
-        link = Link.new({'href' => '/productions/1'}, entry_point)
+        link = Link.new('key', { 'href' => '/productions/1' }, entry_point)
 
         entry_point.connection.expects(:head).with('/productions/1')
-        link.head.inspect
+        link._head.inspect
       end
     end
 
-    describe 'delete' do
+    describe '_delete' do
       it 'sends a DELETE request with the link url' do
-        link = Link.new({'href' => '/productions/1'}, entry_point)
+        link = Link.new('key', { 'href' => '/productions/1' }, entry_point)
 
         entry_point.connection.expects(:delete).with('/productions/1')
-        link.delete.inspect
+        link._delete.inspect
       end
     end
 
-    describe 'post' do
-      let(:link) { Link.new({'href' => '/productions/1'}, entry_point) }
+    describe '_post' do
+      let(:link) { Link.new('key', { 'href' => '/productions/1' }, entry_point) }
 
       it 'sends a POST request with the link url and params' do
-        entry_point.connection.expects(:post).with('/productions/1', {'foo' => 'bar'})
-        link.post({'foo' => 'bar'}).inspect
+        entry_point.connection.expects(:post).with('/productions/1', 'foo' => 'bar')
+        link._post('foo' => 'bar').inspect
       end
 
       it 'defaults params to an empty hash' do
         entry_point.connection.expects(:post).with('/productions/1', {})
-        link.post.inspect
+        link._post.inspect
       end
     end
 
-    describe 'put' do
-      let(:link) { Link.new({'href' => '/productions/1'}, entry_point) }
+    describe '_put' do
+      let(:link) { Link.new('key', { 'href' => '/productions/1' }, entry_point) }
 
       it 'sends a PUT request with the link url and params' do
-        entry_point.connection.expects(:put).with('/productions/1', {'foo' => 'bar'})
-        link.put({'foo' => 'bar'}).inspect
+        entry_point.connection.expects(:put).with('/productions/1', 'foo' => 'bar')
+        link._put('foo' => 'bar').inspect
       end
 
       it 'defaults params to an empty hash' do
         entry_point.connection.expects(:put).with('/productions/1', {})
-        link.put.inspect
+        link._put.inspect
       end
     end
 
-    describe 'patch' do
-      let(:link) { Link.new({'href' => '/productions/1'}, entry_point) }
+    describe '_patch' do
+      let(:link) { Link.new('key', { 'href' => '/productions/1' }, entry_point) }
 
       it 'sends a PATCH request with the link url and params' do
-        entry_point.connection.expects(:patch).with('/productions/1', {'foo' => 'bar'})
-        link.patch({'foo' => 'bar'}).inspect
+        entry_point.connection.expects(:patch).with('/productions/1', 'foo' => 'bar')
+        link._patch('foo' => 'bar').inspect
       end
 
       it 'defaults params to an empty hash' do
         entry_point.connection.expects(:patch).with('/productions/1', {})
-        link.patch.inspect
+        link._patch.inspect
       end
     end
 
     describe 'inspect' do
       it 'outputs a custom-friendly output' do
-        link = Link.new({'href'=>'/productions/1'}, 'foo')
+        link = Link.new('key', { 'href' => '/productions/1' }, 'foo')
 
         link.inspect.must_include 'Link'
         link.inspect.must_include '"href"=>"/productions/1"'
@@ -201,34 +207,53 @@ module Hyperclient
     end
 
     describe 'method_missing' do
-      before do
-        stub_request(:get, "http://myapi.org/orders").
-          to_return(body: '{"resource": "This is the resource"}')
-        Resource.stubs(:new).returns(resource)
+      describe 'delegation' do
+        it 'delegates when link key matches' do
+          resource = Resource.new({ '_links' => { 'orders' => { 'href' => '/orders' } } }, entry_point)
+          stub_request(:get, 'http://api.example.org/orders').to_return(body: { '_embedded' => { 'orders' => [{ 'id' => 1 }] } })
+          resource.orders._embedded.orders.first.id.must_equal 1
+          resource.orders.first.id.must_equal 1
+        end
+
+        it "doesn't delegate when link key doesn't match" do
+          resource = Resource.new({ '_links' => { 'foos' => { 'href' => '/orders' } } }, entry_point)
+          stub_request(:get, 'http://api.example.org/orders').to_return(body: { '_embedded' => { 'orders' => [{ 'id' => 1 }] } })
+          resource.foos._embedded.orders.first.id.must_equal 1
+          resource.foos.first.must_equal nil
+        end
       end
 
-      let(:link) { Link.new({'href' => 'http://myapi.org/orders'}, entry_point) }
-      let(:resource) { mock('Resource') }
+      describe 'resource' do
+        before do
+          stub_request(:get, 'http://myapi.org/orders')
+            .to_return(body: '{"resource": "This is the resource"}')
+          Resource.stubs(:new).returns(resource)
+        end
 
-      it 'delegates unkown methods to the resource' do
-        Resource.expects(:new).returns(resource).at_least_once
-        resource.expects(:embedded)
+        let(:resource) { mock('Resource') }
+        let(:link) { Link.new('orders', { 'href' => 'http://myapi.org/orders' }, entry_point) }
 
-        link.embedded
-      end
+        it 'delegates unkown methods to the resource' do
+          Resource.expects(:new).returns(resource).at_least_once
+          resource.expects(:embedded)
 
-      it 'raises an error when the method does not exist in the resource' do
-        lambda { link.this_method_does_not_exist }.must_raise(NoMethodError)
-      end
+          link.embedded
+        end
 
-      it 'responds to missing methods' do
-        resource.expects(:respond_to?).with('embedded').returns(true)
-        link.respond_to?(:embedded).must_equal true
-      end
+        it 'raises an error when the method does not exist in the resource' do
+          lambda { link.this_method_does_not_exist }.must_raise NoMethodError
+        end
 
-      it 'does not delegate to_ary to resource' do
-        resource.expects(:to_ary).never
-        [[link, link]].flatten.must_equal [link, link]
+        it 'responds to missing methods' do
+          resource.expects(:respond_to?).with('orders').returns(false)
+          resource.expects(:respond_to?).with('embedded').returns(true)
+          link.respond_to?(:embedded).must_equal true
+        end
+
+        it 'does not delegate to_ary to resource' do
+          resource.expects(:to_ary).never
+          [[link, link]].flatten.must_equal [link, link]
+        end
       end
     end
   end