restify 1.10.0 → 1.15.0

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify do
+  let!(:request_stub) do
+    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:9292/base').get.value! }
+
+    context 'for 400 status codes' do
+      let(:http_status) { '400 Bad Request' }
+
+      it 'throws a BadRequest exception' do
+        expect { request }.to raise_error Restify::BadRequest
+      end
+    end
+
+    context 'for 401 status codes' do
+      let(:http_status) { '401 Unauthorized' }
+
+      it 'throws an Unauthorized exception' do
+        expect { request }.to raise_error Restify::Unauthorized
+      end
+    end
+
+    context 'for 404 status codes' do
+      let(:http_status) { '404 Not Found' }
+
+      it 'throws a ClientError exception' do
+        expect { request }.to raise_error Restify::NotFound
+      end
+    end
+
+    context 'for 406 status codes' do
+      let(:http_status) { '406 Not Acceptable' }
+
+      it 'throws a NotAcceptable exception' do
+        expect { request }.to raise_error Restify::NotAcceptable
+      end
+    end
+
+    context 'for 422 status codes' do
+      let(:http_status) { '422 Unprocessable Entity' }
+
+      it 'throws a UnprocessableEntity exception' do
+        expect { request }.to raise_error Restify::UnprocessableEntity
+      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' }
+
+      it 'throws a generic ClientError exception' do
+        expect { request }.to raise_error Restify::ClientError
+      end
+    end
+
+    context 'for any 5xx status codes' do
+      let(:http_status) { '500 Internal Server Error' }
+
+      it 'throws a generic ServerError exception' do
+        expect { request }.to raise_error Restify::ServerError
+      end
+    end
+  end
+end

data/spec/restify/global_spec.rb

@@ -26,10 +26,10 @@ describe Restify::Global do
       let(:options) { {accept: 'application.vnd.github.v3+json'} }
       let(:context) { Restify::Context.new uri, **options }
 
-      subject { global.new name, options }
+      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.
@@ -134,7 +129,6 @@ describe Restify do
         # the result is here.
         expect { create_user_promise.value! }.to \
           raise_error(Restify::ClientError) do |e|
-
           # Because we forgot to send a "name" the server complains
           # with an error code that will lead to a raised error.
 
@@ -195,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)
 
@@ -206,7 +200,6 @@ describe Restify do
 
           expect { create_user_promise.value! }.to \
             raise_error(Restify::ClientError) do |e|
-
             expect(e.status).to eq :unprocessable_entity
             expect(e.code).to eq 422
             expect(e.errors).to eq 'name' => ["can't be blank"]

data/spec/spec_helper.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
 require 'rspec'
-require 'webmock/rspec'
+require 'rspec/collection_matchers'
 
-if ENV['CI'] || (defined?(:RUBY_ENGINE) && RUBY_ENGINE != 'rbx')
-  require 'coveralls'
-  Coveralls.wear! do
-    add_filter 'spec'
-  end
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec'
+end
+
+if ENV['CI']
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
 end
 
 require 'restify'
@@ -31,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')].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
@@ -51,6 +50,7 @@ RSpec.configure do |config|
     ::Logging.logger.root.add_appenders ::Logging.appenders.stdout
   end
 
+  config.warnings = true
   config.after(:suite) do
     EventMachine.stop if defined?(EventMachine) && EventMachine.reactor_running?
   end

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