excon-hypermedia 0.3.0 → 0.4.0

data/lib/excon/hypermedia/response.rb

@@ -21,14 +21,10 @@ module Excon
       def handle(method_name, *params)
         return false unless enabled?
 
-        if method_name == :rel
-          handle_link(params.shift, params)
-        elsif resource.type?(method_name) == :link
-          handle_link(method_name, params)
-        elsif resource.respond_to?(method_name, false)
-          resource.send(method_name, *params)
-        else
-          false
+        case method_name
+        when :resource then resource
+        when :rel      then rel(params.shift, params)
+        else false
         end
       end
 
@@ -37,15 +33,26 @@ module Excon
       attr_reader :response
 
       def resource
-        @resource ||= Resource.new(response.body)
+        @resource ||= ResourceObject.new(body_to_hash)
+      end
+
+      def body_to_hash
+        content_type.include?('application/hal+json') ? JSON.parse(response.body) : {}
+      end
+
+      def content_type
+        response.headers['Content-Type'].to_s
       end
 
       def enabled?
         response.data[:hypermedia] == true
       end
 
-      def handle_link(name, params)
-        Excon.new(resource.link(name).href, params.first.to_h.merge(hypermedia: true))
+      def rel(name, params)
+        link    = resource._links.send(name)
+        options = params.first.to_h.merge(hypermedia: true)
+
+        link.respond_to?(:to_ary) ? link.map { |l| l.rel(options) } : link.rel(options)
       end
     end
   end

data/lib/excon/hypermedia/version.rb

@@ -2,6 +2,6 @@
 
 module Excon
   module HyperMedia
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

data/lib/excon/hypermedia.rb

@@ -2,8 +2,10 @@
 
 require 'excon'
 require 'excon/addressable'
-require 'excon/hypermedia/link'
+
+require 'excon/hypermedia/helpers/collection'
+require 'excon/hypermedia/link_object'
 require 'excon/hypermedia/middleware'
-require 'excon/hypermedia/resource'
+require 'excon/hypermedia/resource_object'
 require 'excon/hypermedia/response'
 require 'excon/hypermedia/version'

data/test/excon/integration_test.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/LineLength
+
+require_relative '../test_helper'
+
+module Excon
+  # IntegrationTest
+  #
+  # Verifies the Excon connection consuming HyperMedia APIs.
+  #
+  class IntegrationTest < HyperMediaTest
+    def api
+      Excon.get('https://www.example.org/api.json')
+    end
+
+    def test_request
+      response = api.rel('product', expand: { uid: 'bicycle' }).get
+
+      assert response.body.include?('https://www.example.org/product/bicycle')
+    end
+
+    def test_request_using_link_rel
+      response = api.resource._links.product.rel(expand: { uid: 'bicycle' }).get
+
+      assert response.body.include?('https://www.example.org/product/bicycle')
+    end
+
+    def test_nested_request
+      bicycle  = api.rel('product', expand: { uid: 'bicycle' }).get
+      response = bicycle.rel('handlebar').get
+
+      assert_equal data(:handlebar)['material'], response.resource.material
+    end
+
+    def test_collection_request
+      bicycle   = api.rel('product', expand: { uid: 'bicycle' }).get
+      wheels    = bicycle.rel('wheels')
+      responses = wheels.map(&:get)
+
+      assert Array, wheels.class
+      assert_equal data(:front_wheel)['position'], responses.first.resource.position
+    end
+
+    def test_expand_in_get
+      response = api.rel('product').get(expand: { uid: 'bicycle' })
+
+      assert response.body.include?('https://www.example.org/product/bicycle')
+    end
+
+    def test_invalid_relation
+      assert_raises(NoMethodError) { api.rel('invalid') }
+    end
+
+    def test_link
+      response = api.rel('product', expand: { uid: 'bicycle' }).get
+
+      assert_equal data(:bicycle)['_links']['handlebar']['href'], response.resource._links.handlebar.href
+    end
+
+    def test_link_collection
+      response = api.rel('product', expand: { uid: 'bicycle' }).get
+
+      assert_equal Array, response.resource._links.wheels.class
+      assert_equal data(:bicycle)['_links']['wheels'][0]['href'], response.resource._links.wheels.first.href
+    end
+
+    def test_nested_attributes
+      response = api.rel('product', expand: { uid: 'bicycle' }).get
+
+      assert_equal 7, response.resource.derailleurs.back
+    end
+
+    def test_invalid_attribute
+      response = api.rel('product', expand: { uid: 'bicycle' }).get
+
+      assert_equal 'Mountain Bike', response.resource['bike-type']
+      assert_equal false, response.resource.bmx
+    end
+
+    def test_embedded_resource
+      response = api.rel('product', expand: { uid: 'bicycle' }).get
+
+      assert_equal Excon::HyperMedia::ResourceObject, response.resource._embedded.pump.class
+      assert_equal '2kg', response.resource._embedded.pump.weight
+    end
+
+    def test_embedded_resource_collection
+      response = api.rel('product', expand: { uid: 'bicycle' }).get
+
+      assert_equal Array, response.resource._embedded.wheels.class
+      assert_equal data(:front_wheel)['position'], response.resource._embedded.wheels.first.position
+    end
+
+    def teardown
+      Excon.stubs.clear
+    end
+  end
+end

data/test/excon/link_object_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/MethodLength
+
+require_relative '../test_helper'
+
+module Excon
+  # LinkTest
+  #
+  # Validate the workings of `Excon::HyperResource::LinkObject`.
+  #
+  class LinkTest < Minitest::Test
+    def self
+      '{ "href": "https://www.example.org/hello" }'
+    end
+
+    def templated
+      '{ "href": "https://www.example.org/hello/{receiver}", "templated": "true" }'
+    end
+
+    def full
+      <<~EOF
+        {
+          "href": "https://www.example.org/goodbye/{receiver}",
+          "templated": "true",
+          "type": "json",
+          "deprecation": true,
+          "name": "goodbye",
+          "profile": "https://profile.example.org",
+          "title": "Goodbye!",
+          "hreflang": "en-gb"
+        }
+      EOF
+    end
+
+    def data(name)
+      JSON.parse(send(name))
+    end
+
+    def link(name)
+      Excon::HyperMedia::LinkObject.new(data(name))
+    end
+
+    def test_link
+      assert_equal data(:self), link(:self).to_h
+    end
+
+    def test_missing_property
+      assert_raises(NoMethodError) { data(:self).name }
+    end
+
+    def test_href
+      assert_equal data(:self)['href'], link(:self).href
+    end
+
+    def test_templated
+      assert link(:templated).templated
+    end
+
+    def test_templated_returns_false_if_undefined
+      refute link(:self).templated
+    end
+
+    def test_type
+      assert_equal data(:full)['type'], link(:full).type
+    end
+
+    def test_deprecation
+      assert_equal data(:full)['deprecation'], link(:full).deprecation
+    end
+
+    def test_name
+      assert_equal data(:full)['name'], link(:full).name
+    end
+
+    def test_profile
+      assert_equal data(:full)['profile'], link(:full).profile
+    end
+
+    def test_title
+      assert_equal data(:full)['title'], link(:full).title
+    end
+
+    def test_hreflang
+      assert_equal data(:full)['hreflang'], link(:full).hreflang
+    end
+
+    def test_uri
+      assert_equal data(:self)['href'], link(:self).uri.to_s
+    end
+  end
+end

data/test/excon/links_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/MethodLength
+
+require_relative '../test_helper'
+
+module Excon
+  # LinksTest
+  #
+  # Validate the workings of `Excon::HyperResource::Resource::Links`.
+  #
+  class LinksTest < Minitest::Test
+    def body
+      <<~EOF
+        {
+          "_links": {
+            "self": {
+              "href": "https://www.example.org/product/bicycle"
+            },
+            "parts": {
+              "href": "https://www.example.org/product/bicycle/parts"
+            }
+          }
+        }
+      EOF
+    end
+
+    def data
+      JSON.parse(body)
+    end
+
+    def links
+      @links ||= Excon::HyperMedia::ResourceObject::Links.new(data['_links'])
+    end
+
+    def test_links
+      assert_equal Excon::HyperMedia::ResourceObject::Links, links.class
+    end
+
+    def test_link_properties
+      assert_equal %w(self parts), links.to_h.keys
+    end
+  end
+end

data/test/excon/properties_test.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/MethodLength
+
+require_relative '../test_helper'
+
+module Excon
+  # PropertiesTest
+  #
+  # Validate the workings of `Excon::HyperResource::Resource::Properties`.
+  #
+  class PropertiesTest < Minitest::Test
+    def body
+      <<~EOF
+        {
+          "size": "49CM",
+          "bike-type": "Mountain Bike",
+          "derailleurs": {
+            "front": 3,
+            "back": 7
+          },
+          "reflectors": true,
+          "BMX": false
+        }
+      EOF
+    end
+
+    def data
+      JSON.parse(body)
+    end
+
+    def properties
+      @properties ||= Excon::HyperMedia::ResourceObject::Properties.new(data)
+    end
+
+    def test_properties
+      assert_equal data, properties.to_h
+    end
+
+    def test_attribute
+      assert_equal properties.size, '49CM'
+    end
+
+    def test_boolean_attribute
+      assert_equal properties.reflectors, true
+    end
+
+    def test_uppercase_attribute_names
+      assert_equal properties.bmx, false
+      assert_equal properties['BMX'], false
+    end
+
+    def test_invalid_attribute_names
+      refute properties.respond_to?('bike-type')
+      assert_equal properties['bike-type'], 'Mountain Bike'
+    end
+
+    def test_nested_attribute
+      assert_equal properties.derailleurs.front, 3
+      assert_equal properties.derailleurs.back, 7
+      assert_equal properties['derailleurs'].back, 7
+    end
+
+    def test_nested_attribute_hash
+      assert_equal properties.derailleurs.to_h, data['derailleurs']
+    end
+  end
+end

data/test/excon/resource_object_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/MethodLength
+
+require_relative '../test_helper'
+
+module Excon
+  # ResourceObjectTest
+  #
+  # Validate the workings of `Excon::HyperResource::ResourceObject`.
+  #
+  class ResourceObjectTest < Minitest::Test
+    def body
+      <<~EOF
+        {
+          "_links": {
+            "hello": {
+              "href": "http://www.example.com/hello/{location}"
+            }
+          },
+          "uid": "universe",
+          "hello": "world"
+        }
+      EOF
+    end
+
+    def data
+      @data ||= JSON.parse(body)
+    end
+
+    def resource
+      @resource ||= Excon::HyperMedia::ResourceObject.new(data)
+    end
+
+    def test_resource
+      assert_equal data, resource.instance_variable_get(:@data)
+    end
+
+    def test_links
+      assert_equal data['_links']['hello']['href'], resource._links.hello.href
+    end
+
+    def test_properties
+      assert_equal 'universe', resource.uid
+      assert_equal 'world', resource.hello
+      assert_equal 'world', resource['hello']
+      assert_equal nil, resource['invalid']
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,4 +1,145 @@
 # frozen_string_literal: true
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/LineLength
+# rubocop:disable Metrics/ClassLength
+# rubocop:disable Metrics/AbcSize
+
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'excon/hypermedia'
 require 'minitest/autorun'
+
+module Excon
+  # HyperMediaTest
+  #
+  class HyperMediaTest < Minitest::Test
+    def setup
+      Excon.defaults[:mock] = true
+      Excon.defaults[:middlewares].push(Excon::HyperMedia::Middleware)
+
+      response = { headers: { 'Content-Type' => 'application/hal+json' } }
+      Excon.stub({ method: :get, path: '/api.json' }, response.merge(body: api_body))
+      Excon.stub({ method: :get, path: '/product/bicycle' }, response.merge(body: bicycle_body))
+      Excon.stub({ method: :get, path: '/product/bicycle/wheels/front' }, response.merge(body: front_wheel_body))
+      Excon.stub({ method: :get, path: '/product/bicycle/wheels/rear' }, response.merge(body: rear_wheel_body))
+      Excon.stub({ method: :get, path: '/product/pump' }, response.merge(body: pump_body))
+      Excon.stub({ method: :get, path: '/product/handlebar' }, response.merge(body: handlebar_body))
+    end
+
+    def teardown
+      Excon.stubs.clear
+      Excon.defaults[:middlewares].delete(Excon::HyperMedia::Middleware)
+      Excon.defaults[:mock] = true
+    end
+
+    def data(name)
+      JSON.parse(send("#{name}_body"))
+    end
+
+    def api_body
+      <<~EOF
+       {
+         "_links": {
+           "self": {
+             "href": "https://www.example.org/api.json"
+           },
+           "product": {
+             "href": "https://www.example.org/product/{uid}",
+             "templated": true
+           }
+         }
+       }
+     EOF
+    end
+
+    def bicycle_body
+      <<~EOF
+        {
+          "_links": {
+            "self": {
+              "href": "https://www.example.org/product/bicycle"
+            },
+            "handlebar": {
+              "href": "https://www.example.org/product/handlebar"
+            },
+            "object_id": {
+              "href": "https://www.example.org/product/bicycle/object_id_as_text"
+            },
+            "pump": {
+              "href": "https://www.example.org/product/pump"
+            },
+            "wheels": [
+              { "href": "https://www.example.org/product/bicycle/wheels/front" },
+              { "href": "https://www.example.org/product/bicycle/wheels/rear" }
+            ]
+          },
+          "bike-type": "Mountain Bike",
+          "BMX": false,
+          "derailleurs": {
+            "back": 7,
+            "front": 3
+          },
+          "name": "bicycle",
+          "reflectors": true,
+          "_embedded": {
+            "pump": #{pump_body},
+            "wheels": [#{front_wheel_body}, #{rear_wheel_body}]
+          }
+        }
+      EOF
+    end
+
+    def handlebar_body
+      <<~EOF
+        {
+          "_links": {
+            "self": "https://www.example.org/product/handlebar"
+          },
+          "material": "Carbon fiber",
+          "reach": "75mm",
+          "bend": "compact"
+        }
+      EOF
+    end
+
+    def pump_body
+      <<~EOF
+        {
+          "_links": {
+            "self": "https://www.example.org/product/pump"
+          },
+          "weight": "2kg",
+          "type": "Floor Pump",
+          "valve-type": "Presta"
+        }
+      EOF
+    end
+
+    def rear_wheel_body
+      <<~EOF
+        {
+          "_links": {
+            "self": {
+              "href": "https://www.example.org/product/bicycle/wheels/rear"
+            }
+          },
+          "position": "rear",
+          "lacing_pattern": "Radial"
+        }
+      EOF
+    end
+
+    def front_wheel_body
+      <<~EOF
+        {
+          "_links": {
+            "self": {
+              "href": "https://www.example.org/product/bicycle/wheels/front"
+            }
+          },
+          "position": "front",
+          "lacing_pattern": "Radial/2-Cross"
+        }
+      EOF
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: excon-hypermedia
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jean
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-18 00:00:00.000000000 Z
+date: 2016-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -141,14 +141,20 @@ files:
 - excon-hypermedia.gemspec
 - lib/excon/hypermedia.rb
 - lib/excon/hypermedia/ext/response.rb
-- lib/excon/hypermedia/link.rb
+- lib/excon/hypermedia/helpers/collection.rb
+- lib/excon/hypermedia/link_object.rb
 - lib/excon/hypermedia/middleware.rb
-- lib/excon/hypermedia/resource.rb
+- lib/excon/hypermedia/resource_object.rb
+- lib/excon/hypermedia/resource_object/embedded.rb
+- lib/excon/hypermedia/resource_object/links.rb
+- lib/excon/hypermedia/resource_object/properties.rb
 - lib/excon/hypermedia/response.rb
 - lib/excon/hypermedia/version.rb
-- test/excon/hypermedia_test.rb
-- test/excon/link_test.rb
-- test/excon/resource_test.rb
+- test/excon/integration_test.rb
+- test/excon/link_object_test.rb
+- test/excon/links_test.rb
+- test/excon/properties_test.rb
+- test/excon/resource_object_test.rb
 - test/test_helper.rb
 homepage: https://github.com/JeanMertz/excon-hypermedia
 licenses:

data/lib/excon/hypermedia/link.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Excon
-  module HyperMedia
-    # Link
-    #
-    # This HyperMedia::Link object encapsulates a link pointing to a resource.
-    #
-    class Link
-      attr_reader :name
-
-      def initialize(name:, hash:)
-        @hash = hash
-        @name = name
-      end
-
-      def valid?
-        link_data.keys.any?
-      end
-
-      def invalid?
-        !valid?
-      end
-
-      def uri
-        ::Addressable::URI.parse(href)
-      end
-
-      def href
-        link_data['href']
-      end
-
-      private
-
-      def link_data
-        @hash.dig('_links', name.to_s) || {}
-      end
-    end
-  end
-end

data/lib/excon/hypermedia/resource.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Excon
-  module HyperMedia
-    # Resource
-    #
-    # This HyperMedia::Resource object encapsulates the returned JSON and
-    # makes it easy to access the links and attributes.
-    #
-    class Resource
-      attr_reader :data
-
-      def initialize(body)
-        @body = body
-      end
-
-      def links
-        data.fetch('_links', {}).keys.map { |name| link(name) }
-      end
-
-      def link(link_name)
-        Link.new(name: link_name, hash: data)
-      end
-
-      def attributes
-        attributes = data.reject do |k, _|
-          k == '_links'
-        end
-
-        Struct.new(*attributes.keys.map(&:to_sym)).new(*attributes.values)
-      end
-
-      def type?(name)
-        return :link if link(name).valid?
-        return :attribute if attributes.respond_to?(name.to_s)
-
-        :unknown
-      end
-
-      def data
-        @data ||= JSON.parse(@body)
-      rescue JSON::ParserError
-        {}
-      end
-    end
-  end
-end