excon-hypermedia 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6bc648cfd5761dfb1236aada3be47b061620a3ad
-  data.tar.gz: f0fc534b110a5de92cbe548a4dbe5eb4bcb6f5e6
+SHA256:
+  metadata.gz: e5194b922b1a5cfda77304bd8800408c6c4bf8c43fd43e94a61cc46c45370860
+  data.tar.gz: 50adb4314587f29da3120b62087afddbd850fb33d62f75d770b225f99c21d482
 SHA512:
-  metadata.gz: 83c3ec47d43ce609a789f2bf0ae0281822ae0b4ba25b00596516ef7ed54e9ecc8ab4f3e834e642172b4a1560da4c8184aa4f6a6ac611f63dc84f22e19b4ee226
-  data.tar.gz: 74fb5d0362acce99b511533c487d18612c81f0c8b455d62633c6fd52e74eb8a262429e6873913e5a5f60e5efae9fdda15132c1602b38a3597e02e0573bf929ea
+  metadata.gz: 25688b9b666becd230dcc00c638e336a9b86eefcd13fd5f56e596b2040318a1786e14c8ed6115a3fc0645062a658758431b45dcb5bd5f46b8489ea45ee35af36
+  data.tar.gz: 177a1f114fa7696aff96cafdab91a433d3743369cd849182aeda3823329f0343f24398117a04219bf787a3cb881afb214ff2c07ed6950fa7b49e47bda4ece0d1

data/.rubocop.yml

@@ -3,8 +3,11 @@ AllCops:
   Exclude:
     - '.wercker/**/*'
 
+Metrics/MethodLength:
+  Max: 15
+
 Metrics/LineLength:
   Max: 100
 
 Lint/EndAlignment:
-  AlignWith: variable
+  EnforcedStyleAlignWith: variable

data/.wercker.yml

@@ -6,6 +6,14 @@ ruby-latest:
     name: tests
     code: bundle exec rake
 
+ruby-25:
+  box: ruby:2.5
+  steps:
+  - bundle-install
+  - script:
+    name: tests
+    code: bundle exec rake
+
 ruby-23:
   box: ruby:2.3
   steps:

data/Gemfile

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
+
 source 'https://rubygems.org'
 gemspec

data/README.md

@@ -280,9 +280,12 @@ pump.resource.weight # => '2kg'
 ```
 
 This feature only works if you are sure the embedded resource is equal to the
-resource returned by the link relation. Because of this requirement, the default
-configuration has `hcp` disabled, you can either enable it per request (which
-also enables it for future requests in the chain), or enable it globally:
+resource returned by the link relation. Also, the embedded resource needs to
+have a `self` link in order to stub the correct endpoint.
+
+Because of these requirement, the default configuration has `hcp` disabled, you
+can either enable it per request (which also enables it for future requests in
+the chain), or enable it globally:
 
 ```ruby
 Excon.defaults[:hcp] = true
@@ -291,7 +294,7 @@ Excon.defaults[:hcp] = true
 ### shortcuts
 
 While the above examples shows the clean separation between the different
-concepts like `response`, `resource`, `links`, `properties` and `emeds`.
+concepts like `response`, `resource`, `links`, `properties` and `embeds`.
 
 Traversing these objects always starts from the response object. To make moving
 around a bit faster, there are several methods available on the

data/Rakefile

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new do |t|
-  t.options = %w(--display-cop-names --extra-details --display-style-guide)
+  t.options = %w[--display-cop-names --extra-details --display-style-guide]
 end
 
 Rake::TestTask.new(:test) do |t|
@@ -13,4 +14,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task default: %i(test rubocop)
+task default: %i[test rubocop]

data/excon-hypermedia.gemspec

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 # encoding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'excon/hypermedia/version'
@@ -7,24 +8,25 @@ require 'excon/hypermedia/version'
 Gem::Specification.new do |spec|
   spec.name          = 'excon-hypermedia'
   spec.version       = Excon::HyperMedia::VERSION
-  spec.authors       = %w(Jean Mertz)
-  spec.email         = %w(jean@mertz.fm)
+  spec.authors       = %w[Jean Mertz]
+  spec.email         = %w[jean@mertz.fm]
 
   spec.summary       = 'Excon, with Hypermedia traversing baked in.'
   spec.description   = 'Excon, with Hypermedia traversing baked in.'
   spec.homepage      = 'https://github.com/JeanMertz/excon-hypermedia'
   spec.license       = 'MIT'
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.require_paths = %w(lib)
+  spec.require_paths = %w[lib]
 
-  spec.add_development_dependency 'bundler', '~> 1.9'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'minitest', '~> 5.0'
-  spec.add_development_dependency 'rubocop', '~> 0.40'
-  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'bundler', '>= 1.15'
   spec.add_development_dependency 'm', '~> 1.5'
+  spec.add_development_dependency 'minitest', '~> 5.11'
+  spec.add_development_dependency 'open4', '~> 1.3'
+  spec.add_development_dependency 'pry', '~> 0.11'
+  spec.add_development_dependency 'rake', '~> 12.3'
+  spec.add_development_dependency 'rubocop', '~> 0.52'
 
   spec.add_dependency 'backport_dig' if RUBY_VERSION < '2.3'
-  spec.add_dependency 'excon', '~> 0.49'
-  spec.add_dependency 'excon-addressable', '~> 0.3'
+  spec.add_dependency 'excon', '~> 0.60'
+  spec.add_dependency 'excon-addressable', '~> 0.4'
 end

data/lib/excon/hypermedia/helpers/collection.rb

@@ -45,10 +45,21 @@ module Excon
       # The second notation returns `nil` on missing keys, the first should do
       # as well.
       #
-      def method_missing(_)
+      def method_missing(_) # rubocop:disable Style/MethodMissing
         nil
       end
 
+      # respond_to_missing?
+      #
+      # Checking if a key exists should be possible using `respond_to?`:
+      #
+      #   collection.respond_to?(:hello_world)
+      #   # => false
+      #
+      def respond_to_missing?(_, _ = false)
+        super
+      end
+
       def to_properties
         collection.each do |key, value|
           key = key.downcase

data/lib/excon/hypermedia/middleware.rb

@@ -5,7 +5,15 @@ require 'backport_dig' if RUBY_VERSION < '2.3'
 Excon.defaults[:middlewares].delete(Excon::Addressable::Middleware)
 Excon.defaults[:middlewares].unshift(Excon::Addressable::Middleware)
 
+# Excon
+#
+# We inject the `expand` key to the allowed lists of keys to be used when
+# creating a request, or connection object. Excon does not enforce this yet, but
+# it does print a warning, so this makes things future-proof.
 module Excon
+  VALID_REQUEST_KEYS.push(:hcp, :embedded, :hypermedia)
+  VALID_CONNECTION_KEYS.push(:hcp, :embedded, :hypermedia)
+
   module HyperMedia
     # Middleware
     #
@@ -17,13 +25,20 @@ module Excon
     #
     class Middleware < Excon::Middleware::Base
       def request_call(datum)
-        orig_stack = @stack
-        @stack = Excon::HyperMedia::Middlewares::HypertextCachePattern.new(orig_stack)
+        # if `hcp` is enabled, insert the `HypertextCachePattern` middleware in
+        # the middleware stack right after this one.
+        if datum[:hcp]
+          orig_stack = @stack
+          @stack = Excon::HyperMedia::Middlewares::HypertextCachePattern.new(orig_stack)
+        end
+
         super
       end
 
       def response_call(datum)
-        return super unless (content_type = datum.dig(:response, :headers, 'Content-Type').to_s)
+        return super unless (headers = datum.dig(:response, :headers))
+        return super unless (match = headers.find { |k, v| k.downcase == 'content-type' })
+        content_type = match[1].to_s
 
         datum[:response][:hypermedia] = if datum[:hypermedia].nil?
           content_type.include?('hal+json')

data/lib/excon/hypermedia/middlewares/hypertext_cache_pattern.rb

@@ -15,43 +15,68 @@ module Excon
         def request_call(datum)
           @datum = datum
 
-          return super unless datum[:hcp] == true && datum[:method] == :get && find_embedded
+          if stubs.any?
+            # We've created new stubs.  The request should be marked as `mocked`
+            # to make sure the stubbed response is returned.
+            datum[:mock] = true
 
-          datum[:response] = {
-            body:      @embedded.to_json,
-            hcp:       true,
-            headers:   content_type_header,
-            remote_ip: '127.0.0.1',
-            status:    200
-          }
+            # The requested resource might not be part of the embedded resources
+            # so we allow external requests.
+            # datum[:allow_unstubbed_requests] = true
+
+            # Make sure Excon's `Mock` middleware runs after this middleware, as
+            # it might have already triggered in the middleware chain.
+            orig_stack = @stack
+            @stack = Excon::Middleware::Mock.new(orig_stack)
+          end
+
+          super
+        rescue StandardError => e
+          raise unless e.class == Excon::Errors::StubNotFound
 
+          # If a request was made to a non-stubbed resource, don't use the Mock
+          # middleware, but simply send the request to the server.
+          @stack = orig_stack
           super
         end
 
-        private
+        def response_call(datum)
+          @datum = datum
 
-        def find_embedded
-          datum.dig(:hcp_params, :embedded).to_h.each do |_, object|
-            break if (@embedded = object_to_embedded(object))
-          end
+          # After the response is returned, remove any request-specific stubs
+          # from Excon, so they can't be accidentally re-used anymore.
+          embedded.each { |r| (match = matcher(r)) && Excon.unstub(match) }
 
-          @embedded
+          super
         end
 
-        def object_to_embedded(object)
-          uri = ::Addressable::URI.new(datum.tap { |h| h.delete(:port) })
+        private
 
-          if object.respond_to?(:to_ary)
-            object.find { |hash| hash.dig('_links', 'self', 'href') == uri.to_s }
-          elsif object.dig('_links', 'self', 'href') == uri.to_s
-            object
-          end
+        def stubs
+          embedded.each { |r| (match = matcher(r)) && Excon.stub(match, response(r)) }.compact
         end
 
-        def content_type_header
-          return {} unless (header = datum.dig(:hcp_params, :content_type))
+        def matcher(resource)
+          return unless (uri = ::Addressable::URI.parse(resource.dig('_links', 'self', 'href')))
+
+          {
+            scheme: uri.scheme,
+            host:   uri.host,
+            path:   uri.path,
+            query:  uri.query
+          }
+        end
+
+        def response(resource)
+          {
+            body:      resource.to_json,
+            hcp:       true,
+            headers:   { 'Content-Type' => 'application/hal+json', 'X-HCP' => 'true' }
+          }
+        end
 
-          { 'Content-Type' => header }
+        def embedded
+          datum[:embedded].to_h.values.flatten
         end
       end
     end

data/lib/excon/hypermedia/resource_object.rb

@@ -11,7 +11,7 @@ module Excon
     # Represents a resource.
     #
     class ResourceObject
-      RESERVED_PROPERTIES = %w(_links _embedded).freeze
+      RESERVED_PROPERTIES = %w[_links _embedded].freeze
 
       def initialize(data)
         @data = data
@@ -58,7 +58,11 @@ module Excon
       end
 
       def method_missing(method_name, *_)
-        _properties.send(method_name)
+        _properties.respond_to?(method_name) ? _properties.send(method_name) : super
+      end
+
+      def respond_to_missing?(method_name, _ = false)
+        _properties.respond_to?(method_name) || super
       end
     end
   end

data/lib/excon/hypermedia/response.rb

@@ -65,12 +65,9 @@ module Excon
 
       def rel_params(params)
         params.merge(
-          hypermedia: true,
           hcp: (params[:hcp].nil? ? response.data[:hcp] : params[:hcp]),
-          hcp_params: {
-            content_type: response.headers['Content-Type'],
-            embedded: resource._embedded
-          }
+          embedded: resource._embedded.to_h,
+          hypermedia: true
         )
       end
     end

data/lib/excon/hypermedia/version.rb

@@ -2,6 +2,6 @@
 
 module Excon
   module HyperMedia
-    VERSION = '0.5.0'
+    VERSION = '0.7.0'
   end
 end

data/test/excon/edgecase_test.rb

@@ -8,22 +8,8 @@ module Excon
   # Validate edge cases (or: non-happy path)
   #
   class EdgeCaseTest < HyperMediaTest
-    def setup
-      Excon.defaults[:mock] = true
-      Excon.defaults[:middlewares].push(Excon::HyperMedia::Middleware)
-
-      response = { headers: { 'Content-Type' => 'application/hal+json' } }
-      Excon.stub({ path: '/api.json' }, response.merge(body: api_body))
-      Excon.stub({ path: '/empty_json' }, response.merge(body: '{}'))
-    end
-
-    def teardown
-      Excon.stubs.clear
-      Excon.defaults[:middlewares].delete(Excon::HyperMedia::Middleware)
-    end
-
-    def api
-      Excon.get('https://www.example.org/api.json')
+    def empty_json_resource
+      empty_json_response.resource
     end
 
     def test_missing_middleware
@@ -47,42 +33,34 @@ module Excon
     end
 
     def test_missing_links
-      resource = Excon.get('https://www.example.org/empty_json').resource
-
-      assert_equal({}, resource._links.to_h)
+      assert_equal({}, empty_json_resource._links.to_h)
     end
 
     def test_missing_embedded
-      resource = Excon.get('https://www.example.org/empty_json').resource
-
-      assert_equal({}, resource._embedded.to_h)
+      assert_equal({}, empty_json_resource._embedded.to_h)
     end
 
     def test_missing_properties
-      resource = Excon.get('https://www.example.org/empty_json').resource
-
-      assert_equal({}, resource._properties.to_h)
+      assert_equal({}, empty_json_resource._properties.to_h)
     end
 
     def test_unknown_property
-      resource = Excon.get('https://www.example.org/api.json').resource
+      assert_nil api.resource._properties.invalid
+      assert_nil api.resource._properties['invalid']
+    end
 
-      assert_equal nil, resource._properties.invalid
-      assert_equal nil, resource._properties['invalid']
+    def test_unknown_property_respond_to
+      assert_equal false, api.resource._properties.respond_to?(:invalid)
     end
 
     def test_unknown_link
-      resource = Excon.get('https://www.example.org/empty_json').resource
-
-      assert_equal nil, resource._links.invalid
-      assert_equal nil, resource._links['invalid']
+      assert_nil empty_json_resource._links.invalid
+      assert_nil empty_json_resource._links['invalid']
     end
 
     def test_unknown_embed
-      resource = Excon.get('https://www.example.org/api.json').resource
-
-      assert_equal nil, resource._embedded.invalid
-      assert_equal nil, resource._embedded['invalid']
+      assert_nil api.resource._embedded.invalid
+      assert_nil api.resource._embedded['invalid']
     end
   end
 end

data/test/excon/hcp_test.rb

@@ -9,28 +9,37 @@ module Excon
   #
   class HCPTest < HyperMediaTest
     def response
-      @response ||= Excon.get('https://example.org/product/bicycle')
+      bicycle
     end
 
     def test_non_hcp_response
-      assert_equal nil, response[:hcp]
+      assert_nil response[:hcp]
     end
 
     def test_hcp_response
       assert response.rel('pump', hcp: true).get[:hcp]
     end
 
+    def test_hcp_response_without_existing_response
+      assert Excon.get(url('/product/bicycle'), hcp: true)
+    end
+
     def test_hcp_response_with_missing_embedding
-      api      = Excon.get('https://www.example.org/api.json')
-      response = api.rel('product', expand: { uid: 'bicycle' }, rel: true).get
+      response = api.rel('product', expand: { uid: 'bicycle' }, hcp: true).get
 
-      assert_equal nil, response[:hcp]
+      assert_nil response[:hcp]
+    end
+
+    def test_hcp_response_with_embedding_but_missing_embed_for_request
+      handlebar = response.rel('handlebar', hcp: true).get
+
+      assert_nil handlebar[:hcp]
     end
 
     def test_hcp_response_with_embedded_array
       wheels = response.rel('wheels', hcp: true)
 
-      assert wheels.map(&:get).all? { |res| res[:hcp] }
+      assert(wheels.map(&:get).all? { |res| res[:hcp] })
     end
 
     def test_nested_hcp_responses
@@ -40,10 +49,6 @@ module Excon
       assert response[:hcp]
     end
 
-    def test_hcp_not_working_for_non_get_requests
-      assert_equal nil, response.rel('pump', hcp: true).post[:hcp]
-    end
-
     def test_hcp_resource
       resource = response.rel('pump', hcp: true).get.resource