restify 2.0.2 → 3.0.0.rc2

data/spec/restify/adapter/loop_lock_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Adapter::LoopLock do
+  subject(:lock) { described_class.new { interrupts << Thread.current } }
+
+  let(:interrupts) { Queue.new }
+  let(:threads) { [] }
+
+  after { threads.each(&:kill).each(&:join) }
+
+  # Run the block in another thread, and wait until it has returned.
+  # The thread is kept alive until the example finished.
+  def other(&)
+    done = Concurrent::Event.new
+    threads << Thread.new do
+      yield
+      done.set
+      sleep
+    end
+    expect(done.wait(1)).to be true
+  end
+
+  def elapsed
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    yield
+    Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+  end
+
+  describe '#acquire' do
+    it 'acquires a free loop' do
+      expect(lock.acquire(1)).to be true
+      expect(lock).to be_owned
+    end
+
+    it 'does not acquire the loop when done' do
+      expect(lock.acquire(1) { true }).to be false
+      expect(lock).not_to be_owned
+    end
+
+    it 'times out while another thread holds the loop' do
+      other { lock.acquire(1) }
+
+      expect(elapsed { expect(lock.acquire(0.1)).to be false }).to be >= 0.1
+      expect(lock).not_to be_owned
+    end
+
+    it 'waits for another thread to release the loop' do
+      acquired = Concurrent::Event.new
+      released = false
+      threads << Thread.new do
+        lock.acquire(1)
+        acquired.set
+        sleep 0.1
+        released = true
+        lock.release
+      end
+      expect(acquired.wait(1)).to be true
+
+      expect(lock.acquire(1)).to be true
+      expect(released).to be true
+    end
+
+    it 'stops waiting when done after being notified' do
+      done = false
+      other { lock.acquire(1) }
+      threads << Thread.new do
+        sleep 0.1
+        done = true
+        lock.notify
+      end
+
+      expect(elapsed { expect(lock.acquire(1) { done }).to be false }).to be < 0.5
+    end
+
+    it 'treats a dead thread as not holding the loop' do
+      Thread.new { lock.acquire(1) }.join
+
+      expect(lock.acquire(0.1)).to be true
+    end
+  end
+
+  describe '#release' do
+    it 'lets a waiting thread acquire the loop' do
+      lock.acquire(1)
+      waiter = Thread.new { lock.acquire(1) }
+      sleep 0.05
+
+      lock.release
+
+      expect(waiter.join(1)&.value).to be true
+      expect(lock).not_to be_owned
+    end
+  end
+
+  describe 'with a background thread' do
+    let(:background) { Queue.new }
+
+    # A background thread running the loop until interrupted, like an
+    # event loop waiting for sockets. Blocks on `interrupts` on purpose,
+    # and is killed after each example.
+    def start_background
+      threads << Thread.new do
+        loop do
+          lock.acquire_background
+          background << :acquired
+          interrupts.pop
+          lock.release
+        end
+      end
+
+      expect(background.pop(timeout: 1)).to eq :acquired
+    end
+
+    it 'interrupts the background thread to release the loop' do
+      start_background
+
+      expect(lock.acquire(1)).to be true
+      expect(background).to be_empty
+    end
+
+    it 'blocks the background thread while a thread holds the loop' do
+      start_background
+      lock.acquire(1)
+
+      sleep 0.1
+      expect(background).to be_empty
+
+      lock.release
+      expect(background.pop(timeout: 1)).to eq :acquired
+    end
+  end
+
+  describe '#reset!' do
+    it 'forgets threads holding the loop' do
+      other { lock.acquire(1) }
+
+      lock.reset!
+
+      expect(lock.acquire(0.1)).to be true
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ describe Restify::Context do
         let(:load) { YAML.load(dump) }
       end
 
-      include_examples 'serialization'
+      it_behaves_like 'serialization'
     end
 
     context 'Marshall' do
@@ -68,7 +68,62 @@ describe Restify::Context do
       let(:dump) { Marshal.dump(context) }
       let(:load) { Marshal.load(dump) } # rubocop:disable Security/MarshalLoad
 
-      include_examples 'serialization'
+      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/opentelemetry_spec.rb

@@ -38,7 +38,7 @@ describe Restify do
       # Latest span has to be from the Ethon instrumentation and must
       # have the Restify span as a parent.
       spans[0].tap do |span|
-        expect(span.instrumentation_scope.name).to match(/Ethon/)
+        expect(span.instrumentation_scope.name).to include('Ethon')
         expect(span.parent_span_id).to eq spans[1].span_id
       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