restify 1.12.0 → 1.15.1

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/global.rb

@@ -39,9 +39,9 @@ module Restify
 
     def resolve_context(uri, **opts)
       if uri.is_a? Symbol
-        Restify::Registry.fetch(uri).inherit(nil, opts)
+        Restify::Registry.fetch(uri).inherit(nil, **opts)
       else
-        Context.new uri, opts
+        Context.new(uri, **opts)
       end
     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/request.rb

@@ -34,18 +34,26 @@ module Restify
       @uri     = opts.fetch(:uri) { raise ArgumentError.new ':uri required.' }
       @data    = opts.fetch(:data, nil)
       @timeout = opts.fetch(:timeout, 300)
-      @headers = opts.fetch(:headers, {}).merge \
-        'Content-Type' => 'application/json'
+      @headers = opts.fetch(:headers, {})
+
+      @headers['Content-Type'] ||= 'application/json' if json?
     end
 
     def body
-      @body ||= begin
-        JSON.dump(data) unless data.nil?
-      end
+      @body ||= json? ? JSON.dump(@data) : @data
     end
 
     def to_s
       "#<#{self.class} #{method.upcase} #{uri}>"
     end
+
+    private
+
+    def json?
+      return false if @data.nil?
+      return false if @data.is_a? String
+
+      true
+    end
   end
 end

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,8 +3,8 @@
 module Restify
   module VERSION
     MAJOR = 1
-    MINOR = 12
-    PATCH = 0
+    MINOR = 15
+    PATCH = 1
     STAGE = nil
     STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.').freeze
 

data/spec/restify/context_spec.rb

@@ -47,7 +47,7 @@ describe Restify::Context do
 
     context 'YAML' do
       let(:dump) { YAML.dump(context) }
-      let(:load) { YAML.load(dump) } # rubocop:disable YAMLLoad
+      let(:load) { YAML.load(dump) } # rubocop:disable Security/YAMLLoad
 
       subject { load }
 
@@ -56,7 +56,7 @@ describe Restify::Context do
 
     context 'Marshall' do
       let(:dump) { Marshal.dump(context) }
-      let(:load) { Marshal.load(dump) } # rubocop:disable MarshalLoad
+      let(:load) { Marshal.load(dump) } # rubocop:disable Security/MarshalLoad
 
       subject { load }
 

data/spec/restify/error_spec.rb

@@ -14,7 +14,6 @@ describe Restify::ResponseError do
     allow(response).to receive(:decoded_body).and_return({})
   end
 
-
   describe '.from_code' do
     subject(:err) { described_class.from_code(response) }
 

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify do
+  let!(:request_stub) do
+    stub_request(:post, 'http://stubserver/base').to_return do
+      <<~HTTP
+        HTTP/1.1 200 OK
+        Link: <http://localhost:9292/other>; rel="neat"
+      HTTP
+    end
+  end
+
+  describe 'Request body' do
+    subject { Restify.new('http://localhost:9292/base').post(body, {}, {headers: headers}).value! }
+    let(:headers) { {} }
+
+    context 'with JSON-like data structures' do
+      let(:body) { {a: 'b', c: 'd'} }
+
+      it 'is serialized as JSON' do
+        subject
+
+        expect(
+          request_stub.with(body: '{"a":"b","c":"d"}')
+        ).to have_been_requested
+      end
+
+      it 'gets a JSON media type for free' do
+        subject
+
+        expect(
+          request_stub.with(headers: {'Content-Type' => 'application/json'})
+        ).to have_been_requested
+      end
+
+      context 'with overridden media type' do
+        let(:headers) { {'Content-Type' => 'application/vnd.api+json'} }
+
+        it 'respects the override' do
+          subject
+
+          expect(
+            request_stub.with(headers: {'Content-Type' => 'application/vnd.api+json'})
+          ).to have_been_requested
+        end
+      end
+    end
+
+    context 'with strings' do
+      let(:body) { 'a=b&c=d' }
+
+      it 'is sent as provided' do
+        subject
+
+        expect(
+          request_stub.with(body: 'a=b&c=d')
+        ).to have_been_requested
+      end
+
+      it 'does not get a JSON media type' do
+        subject
+
+        expect(
+          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/text'} }
+
+        it 'respects the override' do
+          subject
+
+          expect(
+            request_stub.with(headers: {'Content-Type' => 'application/text'})
+          ).to have_been_requested
+        end
+      end
+    end
+  end
+end

data/spec/restify/features/request_errors_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify, adapter: ::Restify::Adapter::Typhoeus do
+  before do
+    stub_request(:get, 'http://stubserver/base').to_timeout
+  end
+
+  describe 'Timeout' do
+    subject(:request) { Restify.new('http://localhost:9292/base').get({}, timeout: 0.1).value! }
+
+    it 'throws a network error' do
+      expect { request }.to raise_error Restify::NetworkError do |error|
+        expect(error.message).to match(/timeout/i)
+      end
+    end
+  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

@@ -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