restify 2.1.0 → 3.0.0.rc3

data/spec/restify/features/redirects_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify do
+  subject(:resource) { Restify.new('http://localhost:9292/old/resource').get.value! }
+
+  before do
+    stub_request(:get, 'http://stubserver/old/resource')
+      .to_return do
+      <<~HTTP
+        HTTP/1.1 302 Found
+        Location: http://localhost:9292/new/resource
+
+      HTTP
+    end
+
+    stub_request(:get, 'http://stubserver/new/resource')
+      .to_return do
+      <<~HTTP
+        HTTP/1.1 200 OK
+        Content-Type: application/json
+
+        {"name":"John Smith","sibling_url":"./sibling"}
+      HTTP
+    end
+  end
+
+  describe 'following redirects' do
+    it 'returns the redirected resource' do
+      expect(resource['name']).to eq 'John Smith'
+      expect(resource.response.code).to eq 200
+    end
+
+    it 'exposes the effective URI on the response' do
+      expect(resource.response.uri.to_s)
+        .to eq 'http://localhost:9292/new/resource'
+    end
+
+    it 'resolves relative relations against the effective URI' do
+      expect(resource.rel(:sibling).expand({}).to_s)
+        .to eq 'http://localhost:9292/new/sibling'
+    end
+  end
+end

data/spec/restify/features/request_errors_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Restify, adapter: 'Restify::Adapter::Typhoeus' do
+describe Restify do
   before do
     stub_request(:get, 'http://stubserver/base').to_timeout
   end

data/spec/restify/features/response_bodies_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify do
+  subject(:resource) { Restify.new('http://localhost:9292/base').get.value! }
+
+  before do
+    stub_request(:get, 'http://stubserver/base')
+      .to_return(
+        status: 200,
+        headers: {
+          'Content-Type' => 'application/json',
+          'Link' => '<http://localhost:9292/other>; rel="other"',
+        },
+        body:,
+      )
+  end
+
+  describe 'Response bodies' do
+    # #31: A content type is set, but the body is empty.
+    context 'when empty' do
+      let(:body) { '' }
+
+      it 'returns a resource without data' do
+        expect(resource.data).to be_nil
+        expect(resource).to have_relation :other
+      end
+    end
+
+    context 'when invalid' do
+      let(:body) { '{"name": ' }
+
+      it 'returns a resource with relations from headers' do
+        expect(resource).to have_relation :other
+      end
+
+      it 'raises on accessing data' do
+        expect { resource.data }.to raise_error(Restify::ParseError, /Could not parse response body/) do |error|
+          expect(error.cause).to be_a JSON::ParserError
+        end
+      end
+    end
+  end
+end

data/spec/restify/features/response_encoding_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify do
+  describe 'Response body encoding' do
+    subject(:response) { Restify.new('http://localhost:9292/base').get.value!.response }
+
+    let(:text) { 'Grüße, Ærø – 日本' }
+
+    before do
+      stub_request(:get, 'http://stubserver/base').to_return(
+        status: 200,
+        headers: {'Content-Type' => content_type},
+        body: body,
+      )
+    end
+
+    context 'with an UTF-8 charset' do
+      let(:content_type) { 'text/plain; charset=UTF-8' }
+      let(:body) { text.encode(Encoding::UTF_8) }
+
+      it 'returns the body in the given encoding' do
+        expect(response.body.encoding).to eq Encoding::UTF_8
+        expect(response.body).to eq text
+      end
+    end
+
+    context 'with an ISO-8859-1 charset' do
+      let(:content_type) { 'text/plain; charset=ISO-8859-1' }
+      let(:text) { 'Grüße, Ærø' }
+      let(:body) { text.encode(Encoding::ISO_8859_1) }
+
+      it 'returns the body in the given encoding' do
+        expect(response.body.encoding).to eq Encoding::ISO_8859_1
+        expect(response.body).to eq text.encode(Encoding::ISO_8859_1)
+        expect(response.body.encode(Encoding::UTF_8)).to eq text
+      end
+    end
+
+    context 'with a quoted charset' do
+      let(:content_type) { 'text/plain; charset="utf-8"' }
+      let(:body) { text.encode(Encoding::UTF_8) }
+
+      it 'returns the body in the given encoding' do
+        expect(response.body.encoding).to eq Encoding::UTF_8
+        expect(response.body).to eq text
+      end
+    end
+
+    context 'with an unknown charset' do
+      let(:content_type) { 'text/plain; charset=nonsense' }
+      let(:body) { text.encode(Encoding::UTF_8) }
+
+      it 'returns the body as binary' do
+        expect(response.body.encoding).to eq Encoding::BINARY
+        expect(response.body.b).to eq text.b
+      end
+    end
+
+    context 'without a charset' do
+      let(:content_type) { 'text/plain' }
+      let(:body) { text.encode(Encoding::UTF_8) }
+
+      it 'returns the body as binary' do
+        expect(response.body.encoding).to eq Encoding::BINARY
+        expect(response.body.b).to eq text.b
+      end
+    end
+
+    context 'with a JSON body' do
+      let(:content_type) { 'application/json; charset=ISO-8859-1' }
+      let(:text) { 'Grüße, Ærø' }
+      let(:body) { %("#{text}").encode(Encoding::ISO_8859_1) }
+
+      it 'decodes the body using the given encoding' do
+        expect(response.body.encoding).to eq Encoding::ISO_8859_1
+        expect(response.decoded_body).to eq text
+      end
+    end
+  end
+end

data/spec/restify/features/response_errors_spec.rb

@@ -5,11 +5,12 @@ require 'spec_helper'
 describe Restify do
   before do
     stub_request(:get, 'http://stubserver/base')
-      .to_return(status: http_status, headers:)
+      .to_return(status: http_status, headers:, body:)
   end
 
   let(:http_status) { '200 OK' }
   let(:headers) { {} }
+  let(:body) { '' }
 
   describe 'Error handling' do
     subject(:request) { Restify.new('http://localhost:9292/base').get.value! }
@@ -20,6 +21,26 @@ describe Restify do
       it 'throws a BadRequest exception' do
         expect { request }.to raise_error Restify::BadRequest
       end
+
+      # #31: Rails sets a JSON content type even for empty bodies.
+      context 'with a JSON content type and an empty body' do
+        let(:headers) { {'Content-Type' => 'application/json'} }
+
+        it 'throws a BadRequest exception' do
+          expect { request }.to raise_error Restify::BadRequest
+        end
+      end
+
+      context 'with an invalid JSON body' do
+        let(:headers) { {'Content-Type' => 'application/json'} }
+        let(:body) { '{"errors": ' }
+
+        it 'throws a BadRequest exception with the raw body as errors' do
+          expect { request }.to raise_error(Restify::BadRequest) do |error|
+            expect(error.errors).to eq '{"errors": '
+          end
+        end
+      end
     end
 
     context 'for 401 status codes' do

data/spec/restify/features/webmock_spec.rb

@@ -4,11 +4,13 @@ require 'spec_helper'
 
 describe Restify do
   before do
-    WebMock.enable!
+    WebMock.enable!(except: %i[typhoeus])
   end
 
   after do
     WebMock.disable!(except: %i[net_http])
+    WebMock.disable_net_connect!
+    WebMock::CallbackRegistry.reset
   end
 
   describe 'WebMock' do
@@ -23,5 +25,94 @@ describe Restify do
     it 'raises error for not stubbed requests' do
       expect { resource }.to raise_error WebMock::NetConnectNotAllowedError
     end
+
+    it 'returns stubbed responses' do
+      stub_request(:get, 'http://www.example.com/base')
+        .to_return(
+          headers: {'Content-Type' => 'application/json', 'X-Custom' => 'yes'},
+          body: '{"name": "restify", "self_url": "http://www.example.com/self"}',
+        )
+
+      expect(resource['name']).to eq 'restify'
+      expect(resource).to have_relation :self
+      expect(resource.response.headers).to include('X_CUSTOM' => 'yes')
+    end
+
+    it 'records requests' do
+      stub_request(:post, 'http://www.example.com/base')
+
+      Restify.new('http://www.example.com/base').post({name: 'restify'}).value!
+
+      expect(
+        a_request(:post, 'http://www.example.com/base')
+          .with(body: {name: 'restify'}.to_json, headers: {'Content-Type' => 'application/json'}),
+      ).to have_been_made.once
+    end
+
+    it 'raises network errors on stubbed timeouts' do
+      stub_request(:get, 'http://www.example.com/base').to_timeout
+
+      expect { resource }.to raise_error Restify::NetworkError, /timeout/i
+    end
+
+    it 'raises stubbed errors' do
+      stub_request(:get, 'http://www.example.com/base').to_raise(Errno::ECONNREFUSED)
+
+      expect { resource }.to raise_error Errno::ECONNREFUSED
+    end
+
+    it 'creates a span for stubbed requests' do
+      stub_request(:get, 'http://www.example.com/base')
+
+      resource
+
+      expect(OTLE_EXPORTER.finished_spans.map {|span| span.instrumentation_scope.name }).to eq ['restify']
+    end
+
+    context 'when disabled' do
+      it 'does not intercept requests' do
+        stub_request(:get, 'http://localhost:9292/echo').to_return(body: 'stubbed')
+        WebMock.disable!(except: %i[net_http])
+
+        expect(Restify.new('http://localhost:9292/echo').get.value!.response.body).not_to eq 'stubbed'
+      end
+    end
+
+    # Like WebMock does for other libcurl-based libraries: Redirects are
+    # returned as they are.
+    it 'returns stubbed redirects as they are' do
+      stub_request(:get, 'http://www.example.com/base')
+        .to_return(status: 302, headers: {'Location' => '/other'})
+
+      expect(resource.response.code).to eq 302
+      expect(resource.response.headers).to include('LOCATION' => '/other')
+      expect(a_request(:get, 'http://www.example.com/other')).not_to have_been_made
+    end
+
+    context 'with net connect allowed' do
+      before { WebMock.allow_net_connect! }
+
+      it 'passes requests on to the adapter' do
+        expect(Restify.new('http://localhost:9292/echo').get.value!.data).to include('REQUEST_METHOD' => 'GET')
+      end
+
+      it 'invokes callbacks for real requests once' do
+        responses = Queue.new
+        WebMock.after_request(real_requests_only: true) do |signature, response|
+          responses << [signature.uri.to_s, response.status[0]]
+        end
+
+        Restify.new('http://localhost:9292/echo').get.value!
+
+        expect(responses.pop(timeout: 1)).to eq ['http://localhost:9292/echo', 200]
+        expect(responses).to be_empty
+      end
+
+      it 'records real requests once' do
+        Restify.new('http://localhost:9292/echo').get.value!
+
+        expect(a_request(:get, 'http://localhost:9292/echo')).to have_been_made.once
+      end
+    end
   end
 end

data/spec/restify/global_spec.rb

@@ -42,16 +42,32 @@ describe Restify::Global do
   describe '#adapter' do
     subject(:adapter) { global.adapter }
 
-    it 'defaults to Typhoeus adapter' do
-      expect(adapter).to be_a Restify::Adapter::Typhoeus
+    around do |example|
+      Restify.adapter.tap do |configured|
+        Restify.adapter = nil
+        example.run
+      ensure
+        Restify.adapter = configured
+      end
+    end
+
+    it 'defaults to Ethon adapter' do
+      expect(adapter).to be_a Restify::Adapter::Ethon
     end
   end
 
   describe '#adapter=' do
     let(:stub) { Object.new }
 
-    # Ensure to reset adapter after these specs!
-    after { Restify.adapter = nil }
+    # Ensure to restore the configured adapter after these specs!
+    around do |example|
+      Restify.adapter.tap do |configured|
+        Restify.adapter = nil
+        example.run
+      ensure
+        Restify.adapter = configured
+      end
+    end
 
     it 'sets a new adapter' do
       global.adapter = stub
@@ -62,8 +78,8 @@ describe Restify::Global do
   describe '#cache' do
     subject(:cache) { global.cache }
 
-    it 'defaults to Typhoeus adapter' do
-      expect(cache).to be_a Restify::Cache
+    it 'is not set by default' do
+      expect(cache).to be_nil
     end
   end
 
@@ -73,7 +89,7 @@ describe Restify::Global do
     # Ensure to reset cache after these specs!
     after { Restify.cache = nil }
 
-    it 'sets a new adapter' do
+    it 'sets a new cache' do
       global.cache = stub
       expect(global.cache).to be stub
     end
@@ -82,9 +98,61 @@ describe Restify::Global do
   describe '#logger' do
     subject(:logger) { global.logger }
 
-    it 'returns Restify root logger' do
-      expect(logger).to be_a Logging::Logger
-      expect(logger).to eq Logging.logger[Restify]
+    around do |example|
+      global.logger.tap do |configured|
+        global.logger = nil
+        example.run
+      ensure
+        global.logger = configured
+      end
+    end
+
+    it 'is not set by default' do
+      expect(logger).to be_nil
+    end
+
+    it 'does not log anything without a logger' do
+      loggable = Class.new { include Restify::Logging }.new
+
+      expect { loggable.debug('message') }.not_to output.to_stdout_from_any_process
+      expect { loggable.error(RuntimeError.new('kaboom')) }.not_to output.to_stderr_from_any_process
+    end
+  end
+
+  describe '#logger=' do
+    let(:configured) { Logger.new(nil) }
+
+    around do |example|
+      global.logger.tap do |previous|
+        example.run
+      ensure
+        global.logger = previous
+      end
+    end
+
+    it 'sets the logger' do
+      global.logger = configured
+
+      expect(global.logger).to be configured
+    end
+
+    it 'is used for messages from Restify' do
+      output = StringIO.new
+      global.logger = Logger.new(output, level: :debug)
+
+      Class.new { include Restify::Logging }.new.debug('message', key: 'value')
+
+      expect(output.string).to include 'message key=value'
+    end
+
+    it 'is used for errors from Restify' do
+      output = StringIO.new
+      global.logger = Logger.new(output)
+
+      stub_const('Loggable', Class.new { include Restify::Logging })
+      Loggable.new.error(RuntimeError.new('kaboom'))
+
+      expect(output.string).to include 'ERROR -- Loggable: kaboom (RuntimeError)'
     end
   end
 end

data/spec/restify/processors/json_spec.rb

@@ -31,6 +31,42 @@ describe Restify::Processors::Json do
 
     before { allow(response).to receive(:body).and_return(body) }
 
+    describe 'empty body' do
+      let(:body) { '' }
+
+      it { is_expected.to be_a Restify::Resource }
+      it { expect(resource.data).to be_nil }
+    end
+
+    describe 'invalid body' do
+      let(:body) { '{"json": ' }
+
+      before do
+        allow(response).to receive_messages(
+          uri: Addressable::URI.parse('http://test.host/'),
+          links: Restify::Link.parse('<http://test.host/other>; rel="other"'),
+        )
+      end
+
+      it { is_expected.to be_a Restify::Resource }
+      it { is_expected.to have_relation :other }
+      it { expect(resource.response).to be response }
+
+      it 'raises on accessing data' do
+        expect { resource.data }.to raise_error(Restify::ParseError) do |error|
+          expect(error.response).to be response
+          expect(error.cause).to be_a JSON::ParserError
+        end
+      end
+
+      it 'raises on accessing delegated data' do
+        expect { resource['json'] }.to raise_error Restify::ParseError
+      end
+
+      it { is_expected.not_to respond_to :each }
+      it { expect(resource.inspect).to include '@error=' }
+    end
+
     describe 'parsing' do
       context 'single object' do
         let(:body) do
@@ -60,6 +96,21 @@ describe Restify::Processors::Json do
         it { expect(resource.relation(:search)).to eq 'https://google.com{?q}' }
       end
 
+      context 'relation fields with relative references' do
+        let(:context) { Restify::Context.new('http://test.host/users/42') }
+        let(:body) do
+          <<-JSON
+            {"items_url": "items", "status_url": "none"}
+          JSON
+        end
+
+        it 'resolves them against the context URI' do
+          expect(resource.relation(:items).expand({}).to_s).to eq 'http://test.host/users/items'
+        end
+
+        it { is_expected.to have_relation :status }
+      end
+
       context 'object with implicit self relation' do
         let(:body) do
           <<-JSON
@@ -70,6 +121,58 @@ describe Restify::Processors::Json do
         it { expect(resource.relation(:self)).to eq '/self' }
       end
 
+      context 'relation fields in any case' do
+        let(:body) do
+          <<-JSON
+            {"Search_URL": "/search", "URL": "/self"}
+          JSON
+        end
+
+        it { expect(resource.relation(:search)).to eq '/search' }
+        it { expect(resource.relation(:self)).to eq '/self' }
+      end
+
+      context 'several fields for the same relation' do
+        let(:body) do
+          <<-JSON
+            {"url": "/first", "self_url": "/second"}
+          JSON
+        end
+
+        it { expect(resource.relation(:self)).to eq '/first' }
+      end
+
+      context 'relation fields without URLs' do
+        let(:body) do
+          <<-JSON
+            {"a_url": null, "c_url": "", "d_url": 42, "e_url": 1.5,
+             "f_url": true, "g_url": {"href": "/g"}, "h_url": ["/h"]}
+          JSON
+        end
+
+        it { expect(resource._restify_relations).to be_empty }
+      end
+
+      context 'fields similar to relations' do
+        let(:body) do
+          <<-JSON
+            {"_url": "/a", "url_b": "/b"}
+          JSON
+        end
+
+        it { expect(resource._restify_relations).to be_empty }
+      end
+
+      context 'relation fields with non-ASCII characters' do
+        let(:body) do
+          <<-JSON
+            {"\u00FCber_url": "/a", "\u212A_url": "/kelvin", "\u212Aurl": "/b"}
+          JSON
+        end
+
+        it { expect(resource._restify_relations).to be_empty }
+      end
+
       context 'single array' do
         let(:body) do
           <<-JSON

data/spec/restify/processors/msgpack_spec.rb

@@ -41,6 +41,42 @@ describe Restify::Processors::Msgpack do
 
     before { allow(response).to receive(:body).and_return(body) }
 
+    describe 'empty body' do
+      let(:body) { '' }
+
+      it { is_expected.to be_a Restify::Resource }
+      it { expect(resource.data).to be_nil }
+    end
+
+    describe 'invalid body' do
+      let(:body) { "\xC1".b }
+
+      before do
+        allow(response).to receive_messages(
+          uri: Addressable::URI.parse('http://test.host/'),
+          links: Restify::Link.parse('<http://test.host/other>; rel="other"'),
+        )
+      end
+
+      it { is_expected.to be_a Restify::Resource }
+      it { is_expected.to have_relation :other }
+      it { expect(resource.response).to be response }
+
+      it 'raises on accessing data' do
+        expect { resource.data }.to raise_error(Restify::ParseError) do |error|
+          expect(error.response).to be response
+          expect(error.cause).to be_a MessagePack::MalformedFormatError
+        end
+      end
+
+      it 'raises on accessing delegated data' do
+        expect { resource['json'] }.to raise_error Restify::ParseError
+      end
+
+      it { is_expected.not_to respond_to :each }
+      it { expect(resource.inspect).to include '@error=' }
+    end
+
     describe 'parsing' do
       context 'single object' do
         let(:body) do