restify 1.13.0 → 1.15.2

data/lib/restify/global.rb

@@ -20,6 +20,7 @@ module Restify
 
     def cache
       @cache ||= begin
+        require 'active_support'
         require 'active_support/cache'
         Restify::Cache.new store: ActiveSupport::Cache::MemoryStore.new
       end

data/lib/restify/logging.rb

@@ -14,7 +14,7 @@ module Restify
           _log_prefix,
           *Array(tag),
           message,
-          _fmt(**kwargs)
+          _fmt(**kwargs),
         ].map(&:to_s).reject(&:empty?).join(' ')
       end
     end

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

@@ -21,12 +21,10 @@ module Restify
         def parse(object, root: false)
           case object
             when Hash
-              data      = object.each_with_object({}, &method(:parse_data))
-              relations = object.each_with_object({}, &method(:parse_rels))
+              data      = object.each_with_object({}) {|each, obj| parse_data(each, obj) }
+              relations = object.each_with_object({}) {|each, obj| parse_rels(each, obj) }
 
-              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,
@@ -34,7 +32,7 @@ module Restify
                 relations: relations
 
             when Array
-              object.map(&method(:parse))
+              object.map {|each| parse(each) }
             else
               object
           end
@@ -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/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/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

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

data/lib/restify/response.rb

@@ -89,7 +89,6 @@ module Restify
     #
     # @return [Array<Link>] Links.
     #
-    # rubocop:disable Metrics/MethodLength
     def links
       @links ||= begin
         if headers['LINK']
@@ -104,7 +103,6 @@ module Restify
         end
       end
     end
-    # rubocop:enable all
 
     # Return content type header from response headers.
     #

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

data/spec/restify/cache_spec.rb

@@ -3,11 +3,11 @@
 require 'spec_helper'
 
 describe Restify::Cache do
+  subject { cache }
+
   let(:store) { double 'store' }
   let(:cache) { described_class.new store }
 
-  subject { cache }
-
   describe '#call' do
     let(:request) { double 'request' }
     let(:promise0) { double 'promise0' }

data/spec/restify/context_spec.rb

@@ -18,27 +18,30 @@ describe Restify::Context do
       end
 
       describe '#adapter' do
-        let(:kwargs) { {adapter: double('adapter')} }
         subject { super().options[:adapter] }
 
+        let(:kwargs) { {adapter: double('adapter')} }
+
         it 'adapter is not serialized' do
           expect(subject).to equal nil
         end
       end
 
       describe '#cache' do
-        let(:kwargs) { {adapter: double('cache')} }
         subject { super().options[:cache] }
 
+        let(:kwargs) { {adapter: double('cache')} }
+
         it 'cache is not serialized' do
           expect(subject).to equal nil
         end
       end
 
       describe '#headers' do
-        let(:kwargs) { {headers: {'Accept' => 'application/json'}} }
         subject { super().options[:headers] }
 
+        let(:kwargs) { {headers: {'Accept' => 'application/json'}} }
+
         it 'all headers are serialized' do
           expect(subject).to eq('Accept' => 'application/json')
         end
@@ -46,20 +49,20 @@ describe Restify::Context do
     end
 
     context 'YAML' do
+      subject { load }
+
       let(:dump) { YAML.dump(context) }
       let(:load) { YAML.load(dump) } # rubocop:disable Security/YAMLLoad
 
-      subject { load }
-
       include_examples 'serialization'
     end
 
     context 'Marshall' do
+      subject { load }
+
       let(:dump) { Marshal.dump(context) }
       let(:load) { Marshal.load(dump) } # rubocop:disable Security/MarshalLoad
 
-      subject { load }
-
       include_examples 'serialization'
     end
   end

data/spec/restify/error_spec.rb

@@ -19,51 +19,61 @@ describe Restify::ResponseError do
 
     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

data/spec/restify/features/head_requests_spec.rb

@@ -4,20 +4,20 @@ 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
@@ -34,7 +34,7 @@ describe Restify do
       it 'adds them to the query string' do
         subject
         expect(
-          request_stub.with(query: {foo: 'bar'})
+          request_stub.with(query: {foo: 'bar'}),
         ).to have_been_requested
       end
     end

data/spec/restify/features/request_bodies_spec.rb

@@ -0,0 +1,84 @@
+# 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,32 +4,31 @@ 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(
         {},
-        {headers: {'Accept' => 'application/msgpack, application/json'}}
+        {headers: {'Accept' => 'application/msgpack, application/json'}},
       ).value!
 
       root.rel(:self).get.value!
 
       expect(request_stub).to have_been_requested.twice
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'}),
       ).to have_been_requested.once
     end
   end
@@ -37,8 +36,8 @@ describe Restify do
   context 'with request headers configured for context' do
     let(:context) do
       Restify.new(
-        'http://localhost/base',
-        headers: {'Accept' => 'application/msgpack, application/json'}
+        'http://localhost:9292/base',
+        headers: {'Accept' => 'application/msgpack, application/json'},
       )
     end
 
@@ -48,39 +47,39 @@ describe Restify do
       root.rel(:self).get.value!
 
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'}),
       ).to have_been_requested.twice
     end
 
     it 'can overwrite headers for single requests' do
       root = context.get(
         {},
-        {headers: {'Accept' => 'application/xml'}}
+        {headers: {'Accept' => 'application/xml'}},
       ).value!
 
       root.rel(:self).get.value!
 
       expect(
-        request_stub.with(headers: {'Accept' => 'application/xml'})
+        request_stub.with(headers: {'Accept' => 'application/xml'}),
       ).to have_been_requested.once
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'}),
       ).to have_been_requested.once
     end
 
     it 'can add additional headers for single requests' do
       root = context.get(
         {},
-        {headers: {'X-Custom' => 'foobar'}}
+        {headers: {'X-Custom' => 'foobar'}},
       ).value!
 
       root.rel(:self).get.value!
 
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'}),
       ).to have_been_requested.twice
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json', 'X-Custom' => 'foobar'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json', 'X-Custom' => 'foobar'}),
       ).to have_been_requested.once
     end
   end

data/spec/restify/features/response_errors_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify do
+  before 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