restify 2.1.0 → 3.0.0.rc2

data/spec/restify/adapter/telemetry_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Adapter::Telemetry do
+  subject(:call) { adapter.call(request).value! }
+
+  let(:adapter) do
+    Class.new(Restify::Adapter::Base) do
+      def call_native(request, writer)
+        writer.fulfill(Restify::Response.new(request, request.uri, 200, {}, ''))
+      end
+    end.new
+  end
+
+  let(:request) { Restify::Request.new(uri:) }
+  let(:span) { OTLE_EXPORTER.finished_spans.last }
+
+  before { call }
+
+  context 'with an explicit port' do
+    let(:uri) { Addressable::URI.parse('https://example.org:8443/resources') }
+
+    it 'records the given port' do
+      expect(span.name).to eq 'GET https://example.org:8443'
+      expect(span.attributes).to eq({
+        'http.request.method' => 'GET',
+        'http.response.status_code' => 200,
+        'server.address' => 'example.org',
+        'server.port' => 8443,
+        'url.full' => 'https://example.org:8443/resources',
+        'url.scheme' => 'https',
+      })
+    end
+  end
+
+  context 'without a port' do
+    let(:uri) { Addressable::URI.parse('https://example.org/resources') }
+
+    it 'records the default port of the scheme' do
+      expect(span.name).to eq 'GET https://example.org:443'
+      expect(span.attributes).to include(
+        'server.port' => 443,
+        'url.full' => 'https://example.org/resources',
+      )
+    end
+  end
+
+  context 'with a URI given as a string' do
+    let(:uri) { 'http://example.org/resources' }
+
+    it 'parses it' do
+      expect(span.name).to eq 'GET http://example.org:80'
+      expect(span.attributes).to include(
+        'server.address' => 'example.org',
+        'server.port' => 80,
+        'url.full' => 'http://example.org/resources',
+      )
+    end
+  end
+end

data/spec/restify/adapter/typhoeus_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Adapter::Typhoeus do
+  let(:request) { Restify::Request.new(uri: 'http://localhost:9292/base') }
+
+  before do
+    stub_request(:get, 'http://stubserver/base').to_return(status: 200, body: '{}')
+  end
+
+  describe 'sync' do
+    let(:adapter) { described_class.new(sync: true) }
+
+    it 'runs requests from many threads' do
+      threads = Array.new(4) do
+        Thread.new { Array.new(10) { adapter.call(request).value!.code } }
+      end
+
+      # Do not hang the suite on a deadlock.
+      expect(threads.map {|thread| thread.join(5)&.value }).to all eq Array.new(10, 200)
+    ensure
+      threads&.each(&:kill)
+    end
+  end
+end

data/spec/restify/cache_spec.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'active_support'
-require 'active_support/cache'
 
 describe Restify::Cache do
   subject(:cache) { described_class.new(store) }
 
-  let(:store) { instance_double(ActiveSupport::Cache::Store) }
+  let(:store) { Object.new }
 
   describe '#call' do
     let(:request) { instance_double(Restify::Request) }

data/spec/restify/context_spec.rb

@@ -71,4 +71,59 @@ describe Restify::Context do
       it_behaves_like 'serialization'
     end
   end
+
+  describe '#request' do
+    subject(:request) { context.request(:get, '/').value! }
+
+    let(:adapter) do
+      response = Restify::Response.new(nil, Addressable::URI.parse(uri), 200, {}, 'body')
+
+      instance_double(Restify::Adapter::Base).tap do |adapter|
+        allow(adapter).to receive(:call).and_return(Restify::Promise.fulfilled(response))
+      end
+    end
+
+    let(:cache) do
+      Object.new.tap do |cache|
+        def cache.call(request)
+          yield(request)
+        end
+      end
+    end
+
+    let(:kwargs) { {adapter:} }
+
+    it 'calls the adapter without a cache' do
+      expect(adapter).to receive(:call).with(Restify::Request)
+
+      request
+    end
+
+    context 'with a cache' do
+      let(:kwargs) { {adapter:, cache:} }
+
+      it 'lets the cache call the adapter' do
+        expect(cache).to receive(:call).with(Restify::Request).and_call_original
+        expect(adapter).to receive(:call).with(Restify::Request)
+
+        request
+      end
+    end
+
+    context 'with a global cache' do
+      around do |example|
+        Restify.cache = cache
+        example.run
+      ensure
+        Restify.cache = nil
+      end
+
+      it 'lets the cache call the adapter' do
+        expect(cache).to receive(:call).with(Restify::Request).and_call_original
+        expect(adapter).to receive(:call).with(Restify::Request)
+
+        request
+      end
+    end
+  end
 end

data/spec/restify/features/protocols_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify do
+  # Restify follows relations from URLs in server responses, and libcurl
+  # supports far more than HTTP. A server must therefore never be able
+  # to make it access e.g. a `file://` or `gopher://` URL.
+  describe 'Protocol restrictions' do
+    subject(:request) { Restify.new(uri).get.value! }
+
+    context 'with a file URI' do
+      let(:uri) { "file://#{File.expand_path(__FILE__)}" }
+
+      it 'refuses the request' do
+        expect { request }.to raise_error Restify::NetworkError, /protocol/i
+      end
+    end
+
+    context 'with a gopher URI' do
+      let(:uri) { 'gopher://localhost:70/1' }
+
+      it 'refuses the request' do
+        expect { request }.to raise_error Restify::NetworkError, /protocol/i
+      end
+    end
+  end
+end

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