restify 1.14.0 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a52b89b2f13d578bc3ee09444ed5a01e6e80597b13f8fed2a10135f482fde561
-  data.tar.gz: 6e98b2d97468fe186a8500e7b88e72e8e174ef13840a76fcf152d2a8dcc57b4d
+  metadata.gz: 241fd43c8e40d2a0c2c839443df03106edf3c8e491cac9338277ff4327a3927f
+  data.tar.gz: d8eea64a1de42ee6eb4666feb510669b69482f24c72a0f5c883f3482143751ca
 SHA512:
-  metadata.gz: 2c61229244ba3cfeb64d37f4328059e2f9c91f394dea86abe522cb2a4b2ce422ce107ca81a5cd5c55ec2d99b9c1409bd1f4fa6ca7ab13d86697e00dda02abb42
-  data.tar.gz: 1dc873a2867f9cb91e55419c7bf831486b3ad86ec28186b7a2d8bac14653518a496f1cd8369a432fa1c74600b0ad91cd25c3094ffd392a9982dac2128a224484
+  metadata.gz: 603395d24a3ecad6d35b217ef2d154cd0982f9cd9181769b2a5aa949e134f0f9af1a15cc731f54a2d700e3bd1162b667240420e5669af20b48c66a1ba84fc2c5
+  data.tar.gz: 89e64dcd00dde5a7711922619380d2003db5f8c42a7cbc473b19678b6ed251134ffe4b4c94b86afaa7efa7dea030c6d43876e57c00c85ea76523f9f7029f6804

data/CHANGELOG.md

@@ -18,6 +18,20 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Breaks
 
 
+## 1.15.0 - (2021-07-09)
+---
+
+### New
+* Improve memory usage when running lots of requests with typhoeus adapter
+* Use hydra for synchronous requests
+* Increased thread stability of typhoeus adapter (new internal queuing mechanism)
+
+### Changes
+* Use Ruby 2.5 as baseline for testing and linting
+* Add Ruby 3.0 to automated testing
+* Changed timing behavior for multiple requests due to new internal queuing mechanism for the typhoeus adapter
+
+
 ## 1.14.0 - (2020-12-15)
 
 ### New

data/lib/restify/adapter/em.rb

@@ -128,12 +128,10 @@ module Restify
         return if EventMachine.reactor_running?
 
         Thread.new do
-          begin
-            EventMachine.run {}
-          rescue StandardError => e
-            puts "#{self.class} -> #{e}\n#{e.backtrace.join("\n")}"
-            raise e
-          end
+          EventMachine.run {}
+        rescue StandardError => e
+          puts "#{self.class} -> #{e}\n#{e.backtrace.join("\n")}"
+          raise e
         end
       end
     end

data/lib/restify/adapter/pooled_em.rb

@@ -63,7 +63,7 @@ module Restify
         #
         def release(conn)
           @available.unshift(conn) if @available.size < @size
-          @used -= 1 if @used > 0
+          @used -= 1 if @used.positive?
 
           logger.debug do
             "[#{conn.uri}] Released to pool (#{@available.size}/#{@used}/#{size})"
@@ -97,7 +97,7 @@ module Restify
         private
 
         def close(conn)
-          @used -= 1 if @used > 0
+          @used -= 1 if @used.positive?
           @host[conn.uri.to_s] -= 1
 
           conn.close
@@ -212,39 +212,37 @@ module Restify
           end
 
           defer.callback do |conn|
-            begin
-              req = conn.send request.method.downcase,
-                keepalive: true,
-                redirects: 3,
-                path: request.uri.normalized_path,
-                query: request.uri.normalized_query,
-                body: request.body,
-                head: request.headers
-
-              req.callback do
-                writer.fulfill Response.new(
-                  request,
-                  req.last_effective_url,
-                  req.response_header.status,
-                  req.response_header,
-                  req.response
-                )
-
-                if req.response_header['CONNECTION'] == 'close'
-                  @pool.remove(conn)
-                else
-                  @pool << conn
-                end
-              end
-
-              req.errback do
+            req = conn.send request.method.downcase,
+              keepalive: true,
+              redirects: 3,
+              path: request.uri.normalized_path,
+              query: request.uri.normalized_query,
+              body: request.body,
+              head: request.headers
+
+            req.callback do
+              writer.fulfill Response.new(
+                request,
+                req.last_effective_url,
+                req.response_header.status,
+                req.response_header,
+                req.response
+              )
+
+              if req.response_header['CONNECTION'] == 'close'
                 @pool.remove(conn)
-                writer.reject(req.error)
+              else
+                @pool << conn
               end
-            rescue Exception => e # rubocop:disable Lint/RescueException
+            end
+
+            req.errback do
               @pool.remove(conn)
-              writer.reject(e)
+              writer.reject(req.error)
             end
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            @pool.remove(conn)
+            writer.reject(e)
           end
         end
       end
@@ -261,12 +259,10 @@ module Restify
         return if EventMachine.reactor_running?
 
         Thread.new do
-          begin
-            EventMachine.run {}
-          rescue StandardError => e
-            logger.error(e)
-            raise e
-          end
+          EventMachine.run {}
+        rescue StandardError => e
+          logger.error(e)
+          raise e
         end
       end
     end

data/lib/restify/adapter/typhoeus.rb

@@ -24,44 +24,39 @@ module Restify
       }.freeze
 
       def initialize(sync: false, options: {}, **kwargs)
-        @sync    = sync
         @hydra   = ::Typhoeus::Hydra.new(**kwargs)
         @mutex   = Mutex.new
-        @signal  = ConditionVariable.new
-        @thread  = nil
         @options = DEFAULT_OPTIONS.merge(options)
+        @queue   = Queue.new
+        @sync    = sync
+        @thread  = nil
+
+        super()
       end
 
       def sync?
         @sync
       end
 
-      # rubocop:disable Metrics/AbcSize
       # rubocop:disable Metrics/MethodLength
       def call_native(request, writer)
         req = convert(request, writer)
 
         if sync?
-          req.run
+          @hydra.queue(req)
+          @hydra.run
         else
-          @mutex.synchronize do
-            debug 'request:add',
-              tag: request.object_id,
-              method: request.method.upcase,
-              url: request.uri
-
-            @hydra.queue(req)
-            @hydra.dequeue_many
-
-            thread.run unless thread.status
-          end
+          debug 'request:add',
+            tag: request.object_id,
+            method: request.method.upcase,
+            url: request.uri
 
-          debug 'request:signal', tag: request.object_id
+          @queue << convert(request, writer)
 
-          @signal.signal
+          thread.run unless thread.status
         end
       end
-      # rubocop:enable all
+      # rubocop:enable Metrics/MethodLength
 
       private
 
@@ -90,10 +85,15 @@ module Restify
             else
               writer.fulfill convert_back(response, request)
             end
+
+            # Add all newly queued requests to active hydra, e.g. requests
+            # queued in a completion callback.
+            dequeue_all
           end
         end
       end
-      # rubocop:enable all
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
 
       def convert_back(response, request)
         uri     = request.uri
@@ -117,38 +117,51 @@ module Restify
           # Recreate thread if nil or dead
           debug 'hydra:spawn'
 
-          @thread = Thread.new { _loop }
+          @thread = Thread.new do
+            Thread.current.name = 'Restify/Typhoeus Background'
+            run
+          end
         end
 
         @thread
       end
 
-      def _loop
-        Thread.current.name = 'Restify/Typhoeus Background'
-        loop { _run }
-      end
+      # rubocop:disable Metrics/MethodLength
+      def run
+        runs = 0
+
+        loop do
+          if @queue.empty? && runs > 100
+            debug 'hydra:gc'
+            GC.start(full_mark: false, immediate_sweep: false)
+            runs = 0
+          end
 
-      def _ongoing?
-        @hydra.queued_requests.any? || @hydra.multi.easy_handles.any?
-      end
+          debug 'hydra:pop'
 
-      # rubocop:disable Metrics/MethodLength
-      def _run
-        debug 'hydra:run'
-        @hydra.run while _ongoing?
-        debug 'hydra:completed'
+          # Wait for next item and add all available requests to hydra
+          @hydra.queue @queue.pop
+          dequeue_all
 
-        @mutex.synchronize do
-          return if _ongoing?
+          debug 'hydra:run'
+          @hydra.run
+          runs += 1
+          debug 'hydra:completed'
+        rescue StandardError => e
+          logger.error(e)
+        end
+      ensure
+        debug 'hydra:exit'
+      end
+      # rubocop:enable Metrics/MethodLength
 
-          debug 'hydra:pause'
-          @signal.wait(@mutex, 60)
-          debug 'hydra:resumed'
+      def dequeue_all
+        loop do
+          @hydra.queue @queue.pop(true)
+        rescue ThreadError
+          break
         end
-      rescue StandardError => e
-        logger.error(e)
       end
-      # rubocop:enable all
 
       def _log_prefix
         "[#{object_id}/#{Thread.current.object_id}]"

data/lib/restify/context.rb

@@ -59,10 +59,10 @@ module Restify
 
       ret = cache.call(request) {|req| adapter.call(req) }
       ret.then do |response|
-        if !response.errored?
-          process response
-        else
+        if response.errored?
           raise ResponseError.from_code(response)
+        else
+          process response
         end
       end
     end

data/lib/restify/error.rb

@@ -34,6 +34,8 @@ module Restify
           Gone.new(response)
         when 422
           UnprocessableEntity.new(response)
+        when 429
+          TooManyRequests.new(response)
         when 400...500
           ClientError.new(response)
         when 500
@@ -110,15 +112,37 @@ module Restify
   # This makes it easy to rescue specific expected error types.
 
   class BadRequest < ClientError; end
+
   class Unauthorized < ClientError; end
+
   class NotFound < ClientError; end
+
   class NotAcceptable < ClientError; end
+
   class Gone < ClientError; end
+
   class UnprocessableEntity < ClientError; end
 
+  class TooManyRequests < ClientError
+    def retry_after
+      case response.headers['RETRY_AFTER']
+        when /^\d+$/
+          DateTime.now + Rational(response.headers['RETRY_AFTER'].to_i, 86_400)
+        when String
+          begin
+            DateTime.httpdate response.headers['RETRY_AFTER']
+          rescue ArgumentError
+            nil
+          end
+      end
+    end
+  end
+
   class InternalServerError < ServerError; end
 
   class BadGateway < GatewayError; end
+
   class ServiceUnavailable < GatewayError; end
+
   class GatewayTimeout < GatewayError; end
 end

data/lib/restify/processors/base.rb

@@ -5,9 +5,7 @@ module Restify
     class Base
       extend Forwardable
 
-      attr_reader :context
-
-      attr_reader :response
+      attr_reader :context, :response
 
       def initialize(context, response)
         @context  = context
@@ -18,9 +16,7 @@ module Restify
         @resource ||= begin
           resource = load
 
-          unless resource.is_a? Restify::Resource
-            resource = Resource.new context, response: response, data: resource
-          end
+          resource = Resource.new context, response: response, data: resource unless resource.is_a? Restify::Resource
 
           resource._restify_response = response
           merge_relations! resource._restify_relations

data/lib/restify/processors/base/parsing.rb

@@ -24,9 +24,7 @@ module Restify
               data      = object.each_with_object({}, &method(:parse_data))
               relations = object.each_with_object({}, &method(:parse_rels))
 
-              if self.class.indifferent_access?
-                data = with_indifferent_access(data)
-              end
+              data = with_indifferent_access(data) if self.class.indifferent_access?
 
               Resource.new context,
                 data: data,
@@ -56,9 +54,7 @@ module Restify
                      return
                  end
 
-          if relations.key?(name) || pair[1].nil? || pair[1].to_s =~ /\A\w*\z/
-            return
-          end
+          return if relations.key?(name) || pair[1].nil? || pair[1].to_s =~ /\A\w*\z/
 
           relations[name] = pair[1].to_s
         end

data/lib/restify/promise.rb

@@ -11,9 +11,7 @@ module Restify
       # When dependencies were passed in, but none are left after flattening,
       # then we don't have to wait for explicit dependencies or resolution
       # through a writer.
-      if !@task && @dependencies.empty? && dependencies.any?
-        complete true, [], nil
-      end
+      complete true, [], nil if !@task && @dependencies.empty? && dependencies.any?
     end
 
     def wait(timeout = nil)

data/lib/restify/resource.rb

@@ -97,7 +97,7 @@ module Restify
       text = {
         '@data' => data,
         '@relations' => @relations
-      }.map {|k, v| k + '=' + v.inspect }.join(' ')
+      }.map {|k, v| "#{k}=#{v.inspect}" }.join(' ')
 
       "#<#{self.class} #{text}>"
     end

data/lib/restify/timeout.rb

@@ -51,9 +51,7 @@ module Restify
           "Timeout must be an number but is #{value}"
       end
 
-      unless value > 0
-        raise ArgumentError.new "Timeout must be > 0 but is #{value.inspect}."
-      end
+      raise ArgumentError.new "Timeout must be > 0 but is #{value.inspect}." unless value.positive?
 
       value
     end

data/lib/restify/version.rb

@@ -3,7 +3,7 @@
 module Restify
   module VERSION
     MAJOR = 1
-    MINOR = 14
+    MINOR = 15
     PATCH = 0
     STAGE = nil
     STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.').freeze

data/spec/restify/features/head_requests_spec.rb

@@ -4,20 +4,19 @@ require 'spec_helper'
 
 describe Restify do
   let!(:request_stub) do
-    stub_request(:head, 'http://localhost/base')
+    stub_request(:head, 'http://stubserver/base')
       .with(query: hash_including({}))
       .to_return do
-      <<-RESPONSE.gsub(/^ {8}/, '')
+      <<~HTTP
         HTTP/1.1 200 OK
         Content-Length: 333
-        Transfer-Encoding: chunked
-        Link: <http://localhost/other>; rel="neat"
-      RESPONSE
+        Link: <http://localhost:9292/other>; rel="neat"
+      HTTP
     end
   end
 
   describe 'HEAD requests' do
-    subject { Restify.new('http://localhost/base').head(params).value! }
+    subject { Restify.new('http://localhost:9292/base').head(params).value! }
     let(:params) { {} }
 
     it 'returns a resource with access to headers' do

data/spec/restify/features/request_bodies_spec.rb

@@ -4,19 +4,16 @@ require 'spec_helper'
 
 describe Restify do
   let!(:request_stub) do
-    stub_request(:post, 'http://localhost/base')
-      .to_return do
-      <<-RESPONSE.gsub(/^ {8}/, '')
+    stub_request(:post, 'http://stubserver/base').to_return do
+      <<~HTTP
         HTTP/1.1 200 OK
-        Content-Length: 333
-        Transfer-Encoding: chunked
-        Link: <http://localhost/other>; rel="neat"
-      RESPONSE
+        Link: <http://localhost:9292/other>; rel="neat"
+      HTTP
     end
   end
 
   describe 'Request body' do
-    subject { Restify.new('http://localhost/base').post(body, {}, {headers: headers}).value! }
+    subject { Restify.new('http://localhost:9292/base').post(body, {}, {headers: headers}).value! }
     let(:headers) { {} }
 
     context 'with JSON-like data structures' do
@@ -66,18 +63,18 @@ describe Restify do
         subject
 
         expect(
-          request_stub.with {|req| req.headers['Content-Type'].nil? }
+          request_stub.with {|req| req.headers['Content-Type'] !~ /json/ }
         ).to have_been_requested
       end
 
       context 'with overridden media type' do
-        let(:headers) { {'Content-Type' => 'application/x-www-form-urlencoded'} }
+        let(:headers) { {'Content-Type' => 'application/text'} }
 
         it 'respects the override' do
           subject
 
           expect(
-            request_stub.with(headers: {'Content-Type' => 'application/x-www-form-urlencoded'})
+            request_stub.with(headers: {'Content-Type' => 'application/text'})
           ).to have_been_requested
         end
       end

data/spec/restify/features/request_headers_spec.rb

@@ -4,20 +4,19 @@ require 'spec_helper'
 
 describe Restify do
   let!(:request_stub) do
-    stub_request(:get, 'http://localhost/base').to_return do
-      <<-RESPONSE.gsub(/^ {8}/, '')
+    stub_request(:get, "http://stubserver/base").to_return do
+      <<~HTTP
         HTTP/1.1 200 OK
         Content-Type: application/json
-        Transfer-Encoding: chunked
-        Link: <http://localhost/base>; rel="self"
+        Link: <http://localhost:9292/base>; rel="self"
 
         { "response": "success" }
-      RESPONSE
+      HTTP
     end
   end
 
   context 'with request headers configured for a single request' do
-    let(:context) { Restify.new('http://localhost/base') }
+    let(:context) { Restify.new('http://localhost:9292/base') }
 
     it 'sends the headers only for that request' do
       root = context.get(
@@ -37,7 +36,7 @@ describe Restify do
   context 'with request headers configured for context' do
     let(:context) do
       Restify.new(
-        'http://localhost/base',
+        'http://localhost:9292/base',
         headers: {'Accept' => 'application/msgpack, application/json'}
       )
     end

data/spec/restify/features/response_errors_spec.rb

@@ -4,21 +4,15 @@ require 'spec_helper'
 
 describe Restify do
   let!(:request_stub) do
-    stub_request(:get, 'http://localhost/base')
-      .to_return do
-      <<-RESPONSE.gsub(/^ {8}/, '')
-        HTTP/1.1 #{http_status}
-        Content-Length: 333
-        Transfer-Encoding: chunked
-        Link: <http://localhost/other>; rel="neat"
-      RESPONSE
-    end
+    stub_request(:get, 'http://stubserver/base')
+      .to_return(status: http_status, headers: headers)
   end
 
   let(:http_status) { '200 OK' }
+  let(:headers) { {} }
 
   describe 'Error handling' do
-    subject(:request) { Restify.new('http://localhost/base').get.value! }
+    subject(:request) { Restify.new('http://localhost:9292/base').get.value! }
 
     context 'for 400 status codes' do
       let(:http_status) { '400 Bad Request' }
@@ -60,6 +54,60 @@ describe Restify do
       end
     end
 
+    context 'for 429 status codes' do
+      let(:http_status) { '429 Too Many Requests' }
+
+      it 'throws a TooManyRequests exception' do
+        expect { request }.to raise_error Restify::TooManyRequests
+      end
+
+      describe 'the exception' do
+        subject(:exception) do
+          exception = nil
+          begin
+            request
+          rescue Restify::TooManyRequests => e
+            exception = e
+          end
+          exception
+        end
+
+        context 'by default' do
+          it 'does not know when to retry again' do
+            expect(exception.retry_after).to be_nil
+          end
+        end
+
+        context 'with Retry-After header containing seconds' do
+          let(:headers) { {'Retry-After' => '120'} }
+
+          it 'determines the date correctly' do
+            now = DateTime.now
+            lower = now + Rational(119, 86_400)
+            upper = now + Rational(121, 86_400)
+
+            expect(exception.retry_after).to be_between(lower, upper)
+          end
+        end
+
+        context 'with Retry-After header containing HTTP date' do
+          let(:headers) { {'Retry-After' => 'Sun, 13 Mar 2033 13:03:33 GMT'} }
+
+          it 'parses the date correctly' do
+            expect(exception.retry_after.to_s).to eq '2033-03-13T13:03:33+00:00'
+          end
+        end
+
+        context 'with Retry-After header containing invalid date string' do
+          let(:headers) { {'Retry-After' => 'tomorrow 12:00:00'} }
+
+          it 'does not know when to retry again' do
+            expect(exception.retry_after).to be_nil
+          end
+        end
+      end
+    end
+
     context 'for any other 4xx status codes' do
       let(:http_status) { '415 Unsupported Media Type' }
 

data/spec/restify/global_spec.rb

@@ -29,7 +29,7 @@ describe Restify::Global do
       subject { global.new(name, **options) }
 
       it 'returns relation for stored registry item' do
-        Restify::Registry.store name, uri, options
+        Restify::Registry.store(name, uri, **options)
 
         expect(subject).to be_a Restify::Relation
         expect(subject.pattern).to eq uri

data/spec/restify_spec.rb

@@ -5,99 +5,94 @@ require 'spec_helper'
 describe Restify do
   context 'as a dynamic HATEOAS client' do
     before do
-      stub_request(:get, 'http://localhost/base').to_return do
-        <<-RESPONSE.gsub(/^ {10}/, '')
+      stub_request(:get, 'http://stubserver/base').to_return do
+        <<~HTTP
           HTTP/1.1 200 OK
           Content-Type: application/json
-          Transfer-Encoding: chunked
-          Link: <http://localhost/base/users{/id}>; rel="users"
-          Link: <http://localhost/base/courses{/id}>; rel="courses"
+          Link: <http://localhost:9292/base/users{/id}>; rel="users"
+          Link: <http://localhost:9292/base/courses{/id}>; rel="courses"
 
           {
-            "profile_url": "http://localhost/base/profile",
-            "search_url": "http://localhost/base/search?q={query}",
+            "profile_url": "http://localhost:9292/base/profile",
+            "search_url": "http://localhost:9292/base/search?q={query}",
             "mirror_url": null
           }
-        RESPONSE
+        HTTP
       end
 
-      stub_request(:get, 'http://localhost/base/users').to_return do
-        <<-RESPONSE.gsub(/^ {10}/, '')
+      stub_request(:get, 'http://stubserver/base/users')
+        .to_return do
+        <<~HTTP
           HTTP/1.1 200 OK
           Content-Type: application/json
-          Transfer-Encoding: chunked
 
           [{
-             "name": "John Smith",
-             "url": "http://localhost/base/users/john.smith",
-             "blurb_url": "http://localhost/base/users/john.smith/blurb",
-             "languages": ["de", "en"]
-           },
-           {
-             "name": "Jane Smith",
-             "self_url": "http://localhost/base/user/jane.smith"
-           }]
-        RESPONSE
+            "name": "John Smith",
+            "url": "http://localhost:9292/base/users/john.smith",
+            "blurb_url": "http://localhost:9292/base/users/john.smith/blurb",
+            "languages": ["de", "en"]
+          },
+          {
+            "name": "Jane Smith",
+            "self_url": "http://localhost:9292/base/user/jane.smith"
+          }]
+        HTTP
       end
 
-      stub_request(:post, 'http://localhost/base/users')
+      stub_request(:post, 'http://stubserver/base/users')
         .with(body: {})
         .to_return do
-        <<-RESPONSE.gsub(/^ {12}/, '')
-            HTTP/1.1 422 Unprocessable Entity
-            Content-Type: application/json
-            Transfer-Encoding: chunked
+        <<~HTTP
+          HTTP/1.1 422 Unprocessable Entity
+          Content-Type: application/json
 
-            {"errors":{"name":["can't be blank"]}}
-        RESPONSE
+          {"errors":{"name":["can't be blank"]}}
+        HTTP
       end
 
-      stub_request(:post, 'http://localhost/base/users')
+      stub_request(:post, 'http://stubserver/base/users')
         .with(body: {name: 'John Smith'})
         .to_return do
-        <<-RESPONSE.gsub(/^ {12}/, '')
-            HTTP/1.1 201 Created
-            Content-Type: application/json
-            Location: http://localhost/base/users/john.smith
-            Transfer-Encoding: chunked
-
-            {
-              "name": "John Smith",
-              "url": "http://localhost/base/users/john.smith",
-              "blurb_url": "http://localhost/base/users/john.smith/blurb",
-              "languages": ["de", "en"]
-            }
-        RESPONSE
+        <<~HTTP
+          HTTP/1.1 201 Created
+          Content-Type: application/json
+          Location: http://localhost:9292/base/users/john.smith
+
+          {
+            "name": "John Smith",
+            "url": "http://localhost:9292/base/users/john.smith",
+            "blurb_url": "http://localhost:9292/base/users/john.smith/blurb",
+            "languages": ["de", "en"]
+          }
+        HTTP
       end
 
-      stub_request(:get, 'http://localhost/base/users/john.smith')
+      stub_request(:get, 'http://stubserver/base/users/john.smith')
         .to_return do
-        <<-RESPONSE.gsub(/^ {10}/, '')
+        <<~HTTP
           HTTP/1.1 200 OK
           Content-Type: application/json
-          Link: <http://localhost/base/users/john.smith>; rel="self"
-          Transfer-Encoding: chunked
+          Link: <http://localhost:9292/base/users/john.smith>; rel="self"
 
           {
             "name": "John Smith",
-            "url": "http://localhost/base/users/john.smith"
+            "url": "http://localhost:9292/base/users/john.smith"
           }
-        RESPONSE
+        HTTP
       end
 
-      stub_request(:get, 'http://localhost/base/users/john.smith/blurb')
+      stub_request(:get, 'http://stubserver/base/users/john.smith/blurb')
         .to_return do
-        <<-RESPONSE.gsub(/^ {10}/, '')
+        <<~HTTP
           HTTP/1.1 200 OK
           Content-Type: application/json
-          Link: <http://localhost/base/users/john.smith>; rel="user"
-          Transfer-Encoding: chunked
+          Link: <http://localhost:9292/base/users/john.smith>; rel="user"
 
           {
             "title": "Prof. Dr. John Smith",
             "image": "http://example.org/avatar.png"
           }
-        RESPONSE
+        HTTP
       end
     end
 
@@ -107,7 +102,7 @@ describe Restify do
 
         # First request the entry resource usually the
         # root using GET and wait for it.
-        root = Restify.new('http://localhost/base').get.value!
+        root = Restify.new('http://localhost:9292/base').get.value!
 
         # Therefore we need the `users` relations of our root
         # resource.
@@ -194,7 +189,7 @@ describe Restify do
         skip 'Seems to be impossible to detect EM scheduled fibers from within'
 
         EM.synchrony do
-          root = Restify.new('http://localhost/base').get.value!
+          root = Restify.new('http://localhost:9292/base').get.value!
 
           users_relation = root.rel(:users)
 

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'rspec'
-require 'webmock/rspec'
+require 'rspec/collection_matchers'
 
 require 'simplecov'
 SimpleCov.start do
@@ -34,17 +34,13 @@ if ENV['ADAPTER']
   end
 end
 
-require 'webmock/rspec'
-require 'rspec/collection_matchers'
-require 'em-synchrony'
-
-Dir[File.expand_path('spec/support/**/*.rb')].sort.each {|f| require f }
+require_relative 'support/stub_server.rb'
 
 RSpec.configure do |config|
   config.order = 'random'
 
   config.before(:suite) do
-    ::Restify::Timeout.default_timeout = 2
+    ::Restify::Timeout.default_timeout = 0.1
   end
 
   config.before(:each) do

data/spec/support/stub_server.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'puma'
+require 'rack'
+require 'webmock'
+require 'webmock/rspec/matchers'
+
+module Stub
+  # This Rack application matches the request received from rack against the
+  # webmock stub database and returns the response.
+  #
+  # A custom server name is used to
+  #   1) has a stable name without a dynamic port for easier `#stub_request`
+  #      calls, and
+  #   2) to ensure no actual request is intercepted (they are send to
+  #      `localhost:<port>`).
+  #
+  # If no stub is found a special HTTP 599 error code will be returned.
+  class Handler
+    def call(env) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      signature = WebMock::RequestSignature.new(
+        env['REQUEST_METHOD'].downcase,
+        "http://stubserver#{env['REQUEST_URI']}"
+      )
+
+      # Extract request headers from rack env. Most header should start with
+      # `HTTP_` but at least content type is present as `CONTENT_TYPE`.
+      headers = {}
+      env.each_pair do |key, value|
+        case key
+          when /^HTTP_(.*)$/, /^(CONTENT_.*)$/
+            headers[Regexp.last_match(1)] = value
+        end
+      end
+
+      # Read request body from socket into string
+      signature.body = env['rack.input'].read
+      signature.headers = headers
+
+      WebMock::RequestRegistry.instance.requested_signatures.put(signature)
+      response = ::WebMock::StubRegistry.instance.response_for_request(signature)
+
+      # If no stub matched `nil` is returned.
+      if response
+        status = response.status
+        status = status.to_s.split(' ', 2) unless status.is_a?(Array)
+        status = Integer(status[0])
+
+        [status, response.headers || {}, [response.body.to_s]]
+      else
+        # Return special HTTP 599 with the error message that would normally
+        # appear on missing stubs.
+        [599, {}, [WebMock::NetConnectNotAllowedError.new(signature).message]]
+      end
+    end
+  end
+
+  class Exception < ::StandardError; end
+
+  # Inject into base adapter to have HTTP 599 (missing stub) error raised as an
+  # extra exception, not just a server error.
+  module Patch
+    def call(request)
+      super.then do |response|
+        next response unless response.code == 599
+
+        raise ::Stub::Exception.new(response.body)
+      end
+    end
+
+    ::Restify::Adapter::Base.prepend(self)
+  end
+
+  class << self
+    def start_server!
+      @server = ::Puma::Server.new(Handler.new)
+      @server.add_tcp_listener('localhost', 9292)
+
+      Thread.new do
+        @server.run
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include WebMock::API
+  config.include WebMock::Matchers
+
+  config.before(:suite) do
+    Stub.start_server!
+
+    # Net::HTTP adapter must be enabled, otherwise webmock fails to create mock
+    # responses from raw strings.
+    WebMock.disable!(except: %i[net_http])
+  end
+
+  config.around(:each) do |example|
+    example.run
+    WebMock.reset!
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restify
 version: !ruby/object:Gem::Version
-  version: 1.14.0
+  version: 1.15.0
 platform: ruby
 authors:
 - Jan Graichen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-15 00:00:00.000000000 Z
+date: 2021-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -209,6 +209,7 @@ files:
 - spec/restify/timeout_spec.rb
 - spec/restify_spec.rb
 - spec/spec_helper.rb
+- spec/support/stub_server.rb
 homepage: https://github.com/jgraichen/restify
 licenses:
 - LGPL-3.0+
@@ -221,14 +222,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: An experimental hypermedia REST client.
@@ -252,3 +253,4 @@ test_files:
 - spec/restify/timeout_spec.rb
 - spec/restify_spec.rb
 - spec/spec_helper.rb
+- spec/support/stub_server.rb