restify 1.10.0 → 1.15.0

data/lib/restify/context.rb

@@ -36,7 +36,7 @@ module Restify
 
     def inherit(uri, **kwargs)
       uri ||= self.uri
-      Context.new uri, kwargs.merge(options)
+      Context.new(uri, **kwargs, **options)
     end
 
     def process(response)
@@ -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

@@ -30,10 +30,22 @@ module Restify
           NotFound.new(response)
         when 406
           NotAcceptable.new(response)
+        when 410
+          Gone.new(response)
         when 422
           UnprocessableEntity.new(response)
+        when 429
+          TooManyRequests.new(response)
         when 400...500
           ClientError.new(response)
+        when 500
+          InternalServerError.new(response)
+        when 502
+          BadGateway.new(response)
+        when 503
+          ServiceUnavailable.new(response)
+        when 504
+          GatewayTimeout.new(response)
         when 500...600
           ServerError.new(response)
         else
@@ -87,14 +99,50 @@ module Restify
   # 5XX status code.
   class ServerError < ResponseError; end
 
+  # A {GatewayError} is the common base class for 502, 503 and 504
+  # response codes often used by load balancers when upstream servers are
+  # failing or not available.
+  #
+  # This can be used to catch "common" gateway responses.
+  class GatewayError < ServerError; end
+
   ###
   # CONCRETE SUBCLASSES FOR TYPICAL STATUS CODES
   #
   # 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/link.rb

@@ -25,10 +25,10 @@ module Restify
     end
 
     class << self
-      REGEXP_URI = /<[^>]*>\s*/
-      REGEXP_PAR = /;\s*\w+\s*=\s*/i
-      REGEXP_QUT = /"[^"]*"\s*/
-      REGEXP_ARG = /\w+\s*/i
+      REGEXP_URI = /<[^>]*>\s*/.freeze
+      REGEXP_PAR = /;\s*\w+\s*=\s*/i.freeze
+      REGEXP_QUT = /"[^"]*"\s*/.freeze
+      REGEXP_ARG = /\w+\s*/i.freeze
 
       def parse(string)
         scanner = StringScanner.new(string.strip)

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)
@@ -23,6 +21,7 @@ module Restify
 
       super
       raise t if incomplete?
+
       self
     end
 

data/lib/restify/relation.rb

@@ -79,6 +79,7 @@ module Restify
 
     def convert_param(value)
       return value.to_param.to_s if value.respond_to?(:to_param)
+
       value
     end
 

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
@@ -61,6 +59,7 @@ module Restify
     class << self
       def new(timeout, *args)
         return timeout if timeout.is_a?(self)
+
         super
       end
     end

data/lib/restify/version.rb

@@ -3,7 +3,7 @@
 module Restify
   module VERSION
     MAJOR = 1
-    MINOR = 10
+    MINOR = 15
     PATCH = 0
     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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::ResponseError do
+  let(:response) { double 'response' }
+  let(:message) { 'Error' }
+  let(:uri) { 'http://localhost' }
+
+  before do
+    allow(response).to receive(:uri).and_return(uri)
+    allow(response).to receive(:code).and_return(code)
+    allow(response).to receive(:message).and_return(message)
+    allow(response).to receive(:decoded_body).and_return({})
+  end
+
+  describe '.from_code' do
+    subject(:err) { described_class.from_code(response) }
+
+    context 'with 400 Bad Request' do
+      let(:code) { 400 }
+      it { is_expected.to be_a ::Restify::BadRequest }
+    end
+
+    context 'with 401 Unauthorized' do
+      let(:code) { 401 }
+      it { is_expected.to be_a ::Restify::Unauthorized }
+    end
+
+    context 'with 404 Unauthorized' do
+      let(:code) { 404 }
+      it { is_expected.to be_a ::Restify::NotFound }
+    end
+
+    context 'with 406 Not Acceptable' do
+      let(:code) { 406 }
+      it { is_expected.to be_a ::Restify::NotAcceptable }
+    end
+
+    context 'with 410 Gone' do
+      let(:code) { 410 }
+      it { is_expected.to be_a ::Restify::Gone }
+    end
+
+    context 'with 422 Unprocessable Entity' do
+      let(:code) { 422 }
+      it { is_expected.to be_a ::Restify::UnprocessableEntity }
+    end
+
+    context 'with 500 Internal Server Error' do
+      let(:code) { 500 }
+      it { is_expected.to be_a ::Restify::InternalServerError }
+    end
+
+    context 'with 502 Bad Gateway' do
+      let(:code) { 502 }
+      it { is_expected.to be_a ::Restify::BadGateway }
+    end
+
+    context 'with 503 Service Unavailable' do
+      let(:code) { 503 }
+      it { is_expected.to be_a ::Restify::ServiceUnavailable }
+    end
+
+    context 'with 504 Gateway Timeout' do
+      let(:code) { 504 }
+      it { is_expected.to be_a ::Restify::GatewayTimeout }
+    end
+  end
+end

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