hal-client 4.2.0 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8007fc0fdf2984a6cdc35d90dfbdc73a020686d4
-  data.tar.gz: a9b99d9d95c268e8be81324cf98ea76427f72c8e
+  metadata.gz: 77b2bd2a2ee75f106ff5dfc1ca7af3bb49c53ac7
+  data.tar.gz: 5e2abf209a2e898da64afb88f0118a58a61a4c47
 SHA512:
-  metadata.gz: bc49c5224b0824b7d5da339467028ce9cb0b61162d3b9d4a18303e3af37fe493d832afa1cfbc65490647cd3c9441580059d5bf43b6247fa10479624685135cd6
-  data.tar.gz: 5eb75a205939f44e074c55ad18d55275c4d9672287e2973b28557e965241fcd562af9611874cddb1c71cdbff2f13b5756e4f3416c36ac7d15661612a7c7247f7
+  metadata.gz: 8bbbb2faa0fcc3cc2f072b9fff4e0acf582509cd554cd0884aaeaa95ddcba4a81fc800970139a37a66550189f7b07eee9d5c4a80a95a301d9fa26b358fa02725
+  data.tar.gz: 25982fec801a367a71d163ce0830e7cbaae826531a1d4d56505d2464a43c3264fb7865768adf740e0aeab7ad05363c5774c838fa1b9ca5d039614d99fdbbe8f1

data/README.md

@@ -136,6 +136,21 @@ doc.put(improved_doc)                                                   # save c
 
 This removes the obsolete link to "John Doe" from the documents list of authors and replaces it with the correct link then performs an HTTP PUT request with the updated document.
 
+### Forms
+
+HalClient supports [Dwolla HAL forms](https://github.com/Dwolla/hal-forms). For example, given a collection with a [`create-form`](https://tools.ietf.org/html/rfc6861#section-3.1) link to a resource with a [`default`](https://github.com/Dwolla/hal-forms#properties) form that creates new members of the collection, the following code would create a new member of `http://example.com/somecollection`.
+
+
+```ruby
+collection = HalClient.get("http://example.com/somecollection")
+create_form = collection.related("create-form").form
+create_form.submit(
+  name: "my item",
+  author_url: URI("http://example.com/john-doe")
+  description: "super duper!"
+)
+
+```
 ### Custom media types
 
 If the API uses one or more a custom mime types we can specify that they be included in the `Accept` header field of each request.

data/hal-client.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "http", ">= 0.8.4", "< 3.0"
   spec.add_dependency "addressable", "~> 2.3"
   spec.add_dependency "multi_json", "~> 1.9"
+  spec.add_dependency "hana", "~> 1.3"
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake", "~> 10.1"

data/lib/hal_client/form/field.rb

@@ -0,0 +1,67 @@
+class HalClient
+  class Form
+    # A single field in a form.
+    #
+    # Current implementation is very basic. It only understands
+    # `hidden` and `string` field types. All other field types are
+    # treated as `string` per the spec.
+    class Field
+
+      # Initializes a new field.
+      #
+      # parsed_json - the parsed JSON of the field
+      def initialize(parsed_json)
+        @aliases = extract_aliases(parsed_json)
+        @value = extract_value(parsed_json)
+        @type = extract_type(parsed_json)
+        @path = extract_path(parsed_json)
+      end
+
+      # Returns the path to which this field should be encoded in JSON documents, if any.
+      attr_reader :path
+
+      def extract_answer(answers)
+        return value if :hidden == type
+
+        key = aliases.find{|maybe_key| answers.has_key?(maybe_key) }
+
+        coerce_value(answers.fetch(key, value))
+      end
+
+      protected
+
+      attr_reader :aliases, :value, :type
+
+      def coerce_value(val)
+        return nil if val.nil?
+
+        val.to_s
+      end
+
+      def extract_aliases(parsed_json)
+        name = parsed_json.fetch("name") {
+          raise ArgumentError, "field doesn't have a name"
+        }
+
+        [name, name.to_sym]
+      end
+
+      def extract_value(parsed_json)
+        parsed_json.fetch("value", nil)
+      end
+
+      def extract_type(parsed_json)
+        case parsed_json["type"]
+        when /hidden/i
+          :hidden
+        else
+          :string
+        end
+      end
+
+      def extract_path(parsed_json)
+        parsed_json["path"]
+      end
+    end
+  end
+end

data/lib/hal_client/form.rb

@@ -0,0 +1,108 @@
+require 'hal_client/form/field'
+require 'hana'
+
+class HalClient
+
+  # A single [Dwolla HAL
+  # form](https://github.com/Dwolla/hal-forms). Instances of this
+  # class allow clients to complete and submit individual forms.
+  #
+  # This is an incomplete implementation of the spec. Thus far it
+  # supports string and hidden fields with JSON encoding. Enhancements
+  # are requested.
+  class Form
+
+    # Initializes a newly created form
+    #
+    # parsed_json - a Hash create by parsing the JSON.
+    # hal_client - the `HalClient` with which to submit the new form.
+    def initialize(parsed_json, hal_client)
+      @hal_client = hal_client
+      @target_tmpl = extract_target_tmpl(parsed_json)
+      @method = extract_method(parsed_json)
+      @content_type = extract_content_type(parsed_json)
+      @fields = extract_fields(parsed_json)
+    end
+
+
+    # Returns the `Addressable::URI` to which this form is targeted
+    def target_url(answers={})
+      target_tmpl.expand(answers)
+    end
+
+    # Returns the `HalClient::Representation` returned from submitting
+    # the form.
+    #
+    # answers - `Hash` containing the answer key to submit. Keys are
+    #   the field names; values are the values to submit.
+    def submit(answers={})
+      if :get == method
+        hal_client.get(target_url(answers))
+      else
+        hal_client.public_send(method, target_url(answers), body(answers), "Content-Type" => content_type)
+      end
+    end
+
+    protected
+
+    attr_reader :target_tmpl, :method, :hal_client, :content_type, :fields
+
+    def extract_target_tmpl(parsed_json)
+      tmpl_str = parsed_json
+                 .fetch("_links")
+                 .fetch("target")
+                 .fetch("href")
+
+      Addressable::Template.new(tmpl_str)
+
+    rescue KeyError
+      raise ArgumentError, "form has no target href"
+    end
+
+    def extract_method(parsed_json)
+      parsed_json
+        .fetch("method")
+        .downcase
+        .to_sym
+
+    rescue KeyError
+      raise ArgumentError, "form doesn't specify a method"
+    end
+
+    def extract_content_type(parsed_json)
+      return nil if :get == method
+
+      parsed_json
+        .fetch("contentType") { raise  ArgumentError, "form doesn't specify a content type" }
+    end
+
+    def extract_fields(parsed_json)
+      parsed_json
+        .fetch("fields") { raise  ArgumentError, "form doesn't have a field member" }
+        .map { |field_json| Field.new(field_json) }
+    end
+
+    def body(answers)
+      case content_type
+      when /json$/i
+        build_json_body(answers)
+      else
+        raise NotImplementedError, "#{content_type} is not a supported content type"
+      end
+    end
+
+    def build_json_body(answers)
+      fields.reduce({}) { |body_thus_far, field|
+        json_inject_answer(body_thus_far, field.extract_answer(answers), field.path)
+      }
+    end
+
+    def json_inject_answer(body, answer, path)
+      patch = Hana::Patch.new [
+        { 'op' => 'add', 'path' => path, 'value' => answer }
+      ]
+
+      patch.apply(body)
+    end
+  end
+end

data/lib/hal_client/representation.rb

@@ -5,6 +5,7 @@ require 'hal_client'
 require 'hal_client/representation_set'
 require 'hal_client/interpreter'
 require 'hal_client/anonymous_resource_locator'
+require 'hal_client/form'
 
 class HalClient
   # HAL representation of a single resource. Provides access to
@@ -262,6 +263,18 @@ class HalClient
         }
     end
 
+    # Returns the specified `Form`
+    #
+    # form_id - the string or symbol id of the form of interest. Default: `"default"`
+    #
+    # Raises `KeyError` if the specified form doesn't exist.
+    def form(form_id="default")
+      parsed_form_json = property("_forms").fetch(form_id.to_s)
+
+      Form.new(parsed_form_json, hal_client)
+    end
+
+
     # Resets this representation such that it will be requested from
     # the upstream on it's next use.
     def reset

data/lib/hal_client/representation_set.rb

@@ -72,6 +72,27 @@ class HalClient
       first.patch(data, options)
     end
 
+
+    # Returns the specified `Form`
+    #
+    # form_id - the string or symbol id of the form of interest. Default: `"default"`
+    #
+    # Raises `KeyError` if the specified form doesn't exist, or if there are duplicates.
+    def form(form_id="default")
+      self
+        .map { |r|
+          begin
+            r.form(form_id)
+          rescue KeyError
+            nil
+          end }
+        .compact
+        .tap do |fs|
+          raise KeyError, "Duplicate `#{form_id}` forms exist" if fs.count > 1
+        end
+        .first
+    end
+
     protected
 
     attr_reader :reprs

data/lib/hal_client/version.rb

@@ -1,3 +1,3 @@
 class HalClient
-  VERSION = "4.2.0"
+  VERSION = "4.3.0"
 end

data/spec/hal_client/form/field_spec.rb

@@ -0,0 +1,151 @@
+require "hal_client/form/field"
+
+RSpec.describe HalClient::Form::Field do
+  describe ".new" do
+    it "works for simplest legal form field" do
+      expect(
+        described_class.new({"name" => "rating", "type" => "string"})
+      ).to behave_like_a described_class
+    end
+
+    it "works for complex field" do
+      expect(
+        described_class.new({ "name" => "rating",
+                              "type" => "string",
+                              "path" => "/foo/bar",
+                              "value" => "ok",
+                              "displayText" => "Rating",
+                              "validations" => {
+                                "required" => true,
+                                "regex" => "(good)|(ok)|(bad)"
+                              },
+                              "multiple" => true,
+                              "accepted" => {
+                                "groupedValues" => [
+                                  { "key" => "group1",
+                                    "displayText" => "Group 1",
+                                    "values" => [
+                                      { "value" => "val1id",
+                                        "key" => "val1",
+                                        "displayText" => "Value 1"
+                                      }
+                                    ]
+                                  }
+                                ]
+                              }
+                            })
+      ).to behave_like_a described_class
+    end
+  end
+
+  describe "#extract_answer(answers)" do
+    context "no default value" do
+      subject { described_class.new(string_field_json) }
+
+      it "handles string answer keys" do
+        expect(
+          subject.extract_answer("rating" => "bad")
+        ).to eq "bad"
+      end
+
+      it "coerces non-string answers" do
+        expect(
+          subject.extract_answer("rating" => URI("http://example.com/ratings/good"))
+        ).to eq "http://example.com/ratings/good"
+      end
+
+      it "handles symbol answer keys" do
+        expect(
+          subject.extract_answer(rating: "bad")
+        ).to eq "bad"
+      end
+
+      it "returns nil if answer is missing" do
+        expect(
+          subject.extract_answer(foo: 1)
+        ).to be nil
+      end
+    end
+
+    context "with default value" do
+      subject {
+        described_class.new(field_json(name: "rating", value: "ok"))
+      }
+
+      it "returns default value when answer is missing" do
+        expect(
+          subject.extract_answer(foo: 1)
+        ).to eq "ok"
+      end
+
+      it "returns answer when available" do
+        expect(
+          subject.extract_answer(rating: "bad")
+        ).to eq "bad"
+      end
+
+    end
+
+    context "hidden field" do
+      subject {
+        described_class.new(field_json(type: "hidden", name: "rating", value: "ok"))
+      }
+
+      it "ignore answer and use default" do
+        expect(
+          subject.extract_answer(rating: "bad")
+        ).to eq "ok"
+      end
+    end
+  end
+
+  describe "#path" do
+    context "path explicitly specified" do
+      subject { described_class.new(field_json(path: "/rating/value")) }
+
+      it "returns the path" do
+        expect(
+          subject.path
+        ).to eq "/rating/value"
+      end
+    end
+
+    context "path omitted" do
+      subject { described_class.new(field_json(path: MISSING)) }
+
+      it "returns the path" do
+        expect(
+          subject.path
+        ).to be nil
+      end
+    end
+  end
+
+  MISSING = Object.new
+
+  def field_json(type: "string", name: "rating", path: MISSING, value: MISSING)
+    { "name" => name,
+      "type" => type }
+    .tap{|f|
+      f["path"] = path if provided?(path)
+      f["value"] = value if provided?(value)
+    }
+  end
+
+  def provided?(thing)
+    MISSING != thing
+  end
+
+  def string_field_json
+    field_json(type: "string")
+  end
+
+  def string_field_json_with_default
+    field_json(type: "string", value: "ok")
+  end
+
+  def hidden_field_json
+    field_json(type: "hidden", value: "ok")
+  end
+
+end

data/spec/hal_client/form_spec.rb

@@ -0,0 +1,113 @@
+require "hal_client/form"
+require "hal-client"
+
+RSpec.describe HalClient::Form do
+  describe ".new" do
+    specify { expect( HalClient::Form.new(fieldless_get_form, a_client) ).to behave_like_a HalClient::Form }
+  end
+
+  describe "#target_url" do
+    context "vanilla target" do
+      subject { HalClient::Form.new(fieldless_get_form, a_client) }
+
+      specify { expect( subject.target_url ).to eq(Addressable::URI.parse("http://example.com")) }
+    end
+
+    context "templated target" do
+      subject { HalClient::Form.new(get_form_with_fields_and_templated_target, a_client) }
+
+      specify { expect( subject.target_url(rating: 4, description: "pretty good" ) )
+                .to eq(Addressable::URI.parse("http://example.com/?description=pretty%20good&rating=4")) }
+
+    end
+  end
+
+  describe "#submit" do
+    context "fieldless GET form" do
+      subject { HalClient::Form.new(fieldless_get_form, a_client) }
+      let!(:get_request) { stub_request(:get, subject.target_url).to_return(body: "") }
+
+      specify { expect{ subject.submit }.to make_http_request(get_request) }
+    end
+
+    context "GET form w/ fields and templated target" do
+      subject { HalClient::Form.new(get_form_with_fields_and_templated_target, a_client) }
+
+      specify {
+        expect{
+          subject.submit(rating: 4, description: "pretty good")
+        }.to make_http_request(
+               stub_request(:get, subject.target_url(rating: 4, description: "pretty good"))
+             )
+      }
+    end
+
+    context "POST form w/ fields and json content type" do
+      subject { HalClient::Form.new(post_form_with_fields_and_json_content_type, a_client) }
+
+      specify {
+        expect{
+          subject.submit(rating: "ok", description: "pretty good")
+        }.to make_http_request(
+               stub_request(:post, subject.target_url)
+               .with(body: { rating: "ok", description: "pretty good" },
+                     headers: { "Content-Type" => "application/json" })
+             )
+      }
+    end
+
+  end
+
+  # Background
+
+  def fieldless_get_form
+    { "_links" => {
+        "target" => {
+          "href" => "http://example.com"
+        }
+      },
+      "method" => "GET",
+      "fields" => []
+    }
+  end
+
+  def get_form_with_fields_and_templated_target
+    { "_links" => {
+        "target" => {
+          "href" => "http://example.com/{?description,rating}",
+          "templated" => true
+        }
+      },
+      "method" => "GET",
+      "fields" => [
+        { "name" => "rating",
+          "type" => "string" },
+        { "name" => "description",
+          "type" => "text" }
+      ]
+    }
+  end
+
+  def post_form_with_fields_and_json_content_type
+    { "_links" => {
+        "target" => {
+          "href" => "http://example.com/"
+        }
+      },
+      "method" => "POST",
+      "contentType" => "application/json",
+      "fields" => [
+        { "name" => "rating",
+          "type" => "number",
+          "path" => "/rating" },
+        { "name" => "description",
+          "type" => "text",
+          "path" => "/description" }
+      ]
+    }
+  end
+
+  def a_client
+    HalClient.new
+  end
+end

data/spec/hal_client/representation_set_spec.rb

@@ -115,6 +115,124 @@ RSpec.describe HalClient::RepresentationSet do
     end
   end
 
+  describe "#form" do
+    context "single representation with default form" do
+      subject(:repr_single_set) { described_class.new([repr_with_default_form]) }
+
+      specify { expect(
+                  subject.form
+                ).to behave_like_a HalClient::Form }
+
+      specify { expect(
+                  subject.form
+                ).to target "default-form" }
+
+      specify { expect(
+                  subject.form("default")
+                ).to behave_like_a HalClient::Form }
+
+      specify { expect(
+                  subject.form("default")
+                ).to target "default-form" }
+
+    end
+
+    context "multiple representations with default form" do
+      subject(:repr_single_set) { described_class.new([repr_with_default_form,
+                                                       repr_with_default_form]) }
+
+      specify { expect{
+                  subject.form
+                }.to raise_error KeyError }
+
+      specify { expect{
+                  subject.form("default")
+                }.to raise_error KeyError }
+
+      specify { expect{
+                  subject.form(:default)
+                }.to raise_error KeyError }
+    end
+
+    context "multiple representations with unique forms" do
+      subject(:repr_single_set) { described_class.new([repr_with_default_form,
+                                                       repr_with_foo_form]) }
+
+      specify { expect(
+                  subject.form
+                ).to behave_like_a HalClient::Form }
+
+      specify { expect(
+                  subject.form
+                ).to target "default-form" }
+
+      specify { expect(
+                  subject.form("default")
+                ).to behave_like_a HalClient::Form }
+
+      specify { expect(
+                  subject.form("default")
+                ).to target "default-form" }
+
+
+      specify { expect(
+                  subject.form("foo")
+                ).to target "foo-form" }
+
+      specify { expect(
+                  subject.form("foo")
+                ).to behave_like_a HalClient::Form }
+
+      specify { expect(
+                  subject.form(:foo)
+                ).to target "foo-form" }
+
+      specify { expect(
+                  subject.form(:foo)
+                ).to behave_like_a HalClient::Form }
+
+    end
+
+    matcher :target do |expected_target_url|
+      match do |actual_form|
+        expect(actual_form.target_url.to_s).to eq expected_target_url
+      end
+    end
+
+    let(:repr_with_default_form) {
+      HalClient::Representation.new(
+        hal_client: a_client,
+        parsed_json: inject_form(form_json(target: "default-form"), as: "default",
+                                 into: {}))
+    }
+
+    let(:repr_with_foo_form) {
+      HalClient::Representation.new(
+        hal_client: a_client,
+        parsed_json: inject_form(form_json(target: "foo-form"), as: "foo",
+                                 into: {}))
+    }
+
+    def inject_form(form_json, as:, into: )
+      into["_forms"] ||= {}
+      into["_forms"][as] = form_json
+
+      into
+    end
+
+    def form_json(target:)
+      { "_links" => {
+          "target" => {
+            "href" => target
+          }
+        },
+        "method" => "GET",
+        "fields" => []
+      }
+    end
+  end
+
+
   let(:a_client) { HalClient.new }
 
   let(:foo_repr) { HalClient::Representation.new hal_client: a_client, parsed_json: MultiJson.load(foo_hal)}

data/spec/hal_client/representation_spec.rb

@@ -119,6 +119,98 @@ HAL
     end
   end
 
+  describe "#form" do
+    context "default form" do
+      subject(:repr) {
+        HalClient::Representation.new(
+          hal_client: a_client,
+          parsed_json: inject_form(form_json(target: "default-form"), as: "default",
+                                   into: {}))
+      }
+
+      specify { expect(
+                  repr.form
+                ).to target "default-form" }
+
+      specify { expect(
+                  repr.form
+                ).to behave_like_a HalClient::Form }
+
+      specify { expect(
+                  repr.form("default")
+                ).to target "default-form" }
+
+      specify { expect(
+                  repr.form("default")
+                ).to behave_like_a HalClient::Form }
+    end
+
+    context "non-default form" do
+      subject(:repr) {
+        HalClient::Representation.new(
+          hal_client: a_client,
+          parsed_json: inject_form(form_json(target: "foo-form"), as: "foo", into: {}))
+      }
+
+      specify { expect(
+                  repr.form("foo")
+                ).to target "foo-form" }
+
+      specify { expect(
+                  repr.form(:foo)
+                ).to target "foo-form"
+      }
+
+      specify { expect{
+                  repr.form("nonexistent")
+                }.to raise_error KeyError }
+    end
+
+    context "multiple forms" do
+      subject(:repr) {
+        HalClient::Representation.new(
+          hal_client: a_client,
+          parsed_json: {}.tap { |hal|
+            inject_form(form_json(target: "foo-form"), as: "foo", into: hal)
+            inject_form(form_json(target: "bar-form"), as: "bar", into: hal)
+          }
+        )
+      }
+
+      specify { expect(
+                  repr.form("foo")
+                ).to target "foo-form" }
+
+      specify { expect(
+                  repr.form("bar")
+                ).to target "bar-form" }
+    end
+
+    matcher :target do |expected_target_url|
+      match do |actual_form|
+        expect(actual_form.target_url.to_s).to eq expected_target_url
+      end
+    end
+
+    def inject_form(form_json, as:, into: )
+      into["_forms"] ||= {}
+      into["_forms"][as] = form_json
+
+      into
+    end
+
+    def form_json(target:)
+      { "_links" => {
+          "target" => {
+            "href" => target
+          }
+        },
+        "method" => "GET",
+        "fields" => []
+      }
+    end
+  end
+
   context "equality and hash" do
     let(:repr_same_href) { described_class.new(hal_client: a_client,
                                          parsed_json: MultiJson.load(<<-HAL)) }

data/spec/support/custom_matchers.rb

@@ -1,5 +1,10 @@
 module CustomMatchers
   extend RSpec::Matchers::DSL
+  matcher :behave_like_a do |expected_class|
+    match do |actual_instance|
+      (expected_class.instance_methods - actual_instance.class.instance_methods).empty?
+    end
+  end
 
   matcher :be_equivalent_json_to do |expected_json|
     match do |actual_json|
@@ -16,4 +21,15 @@ module CustomMatchers
       end
     end
   end
+
+  matcher :make_http_request do |expected_request|
+    match do |actual_code_under_test|
+      actual_code_under_test.call()
+      expect(expected_request).to have_been_made
+    end
+
+    def supports_block_expectations?
+      true
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hal-client
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.3.0
 platform: ruby
 authors:
 - Peter Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-16 00:00:00.000000000 Z
+date: 2018-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http
@@ -58,6 +58,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: hana
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -172,6 +186,8 @@ files:
 - lib/hal_client/collection.rb
 - lib/hal_client/curie_resolver.rb
 - lib/hal_client/errors.rb
+- lib/hal_client/form.rb
+- lib/hal_client/form/field.rb
 - lib/hal_client/interpreter.rb
 - lib/hal_client/link.rb
 - lib/hal_client/links_section.rb
@@ -183,6 +199,8 @@ files:
 - lib/hal_client/version.rb
 - spec/hal_client/collection_spec.rb
 - spec/hal_client/curie_resolver_spec.rb
+- spec/hal_client/form/field_spec.rb
+- spec/hal_client/form_spec.rb
 - spec/hal_client/interpreter_spec.rb
 - spec/hal_client/link_spec.rb
 - spec/hal_client/links_section_spec.rb
@@ -220,6 +238,8 @@ summary: Use HAL APIs easily
 test_files:
 - spec/hal_client/collection_spec.rb
 - spec/hal_client/curie_resolver_spec.rb
+- spec/hal_client/form/field_spec.rb
+- spec/hal_client/form_spec.rb
 - spec/hal_client/interpreter_spec.rb
 - spec/hal_client/link_spec.rb
 - spec/hal_client/links_section_spec.rb