restify 3.0.0.rc2 → 3.0.0.rc3

data/spec/restify/adapter/ethon/options_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Adapter::Ethon::Options do
+  subject(:options) { described_class.new(values) }
+
+  def number(name)
+    described_class.number(name)
+  end
+
+  describe '#to_a' do
+    subject(:compiled) { options.to_a }
+
+    context 'with bool options' do
+      let(:values) { {followlocation: true, verbose: false, tcp_keepalive: 0} }
+
+      it 'converts to 1 or 0' do
+        expect(compiled).to eq [
+          [number(:followlocation), :long, 1],
+          [number(:verbose), :long, 0],
+          [number(:tcp_keepalive), :long, 0],
+        ]
+      end
+    end
+
+    context 'with int options' do
+      let(:values) { {timeout_ms: 1500, maxredirs: '5'} }
+
+      it { expect(compiled).to eq [[number(:timeout_ms), :long, 1500], [number(:maxredirs), :long, 5]] }
+    end
+
+    context 'with enum options' do
+      let(:values) { {sslversion: :tlsv1, proxytype: 'https', timecondition: 1} }
+
+      it 'converts symbols, strings, and numbers' do
+        expect(compiled).to eq [
+          [number(:sslversion), :long, 1],
+          [number(:proxytype), :long, 2],
+          [number(:timecondition), :long, 1],
+        ]
+      end
+    end
+
+    context 'with bitmask options' do
+      let(:values) { {protocols: %i[http https], redir_protocols: :https} }
+
+      it { expect(compiled).to eq [[number(:protocols), :long, 3], [number(:redir_protocols), :long, 2]] }
+    end
+
+    context 'with string options' do
+      let(:values) { {useragent: :restify} }
+
+      it { expect(compiled).to eq [[number(:useragent), :string, 'restify']] }
+    end
+
+    context 'with nil values' do
+      let(:values) { {useragent: nil, timeout_ms: 5} }
+
+      it { expect(compiled).to eq [[number(:timeout_ms), :long, 5]] }
+    end
+
+    context 'with other option types' do
+      let(:values) { {postquote: []} }
+
+      it 'uses the generic handling' do
+        expect(compiled).to eq [[:postquote, nil, []]]
+      end
+    end
+  end
+
+  describe '#initialize' do
+    it 'raises on unknown options' do
+      expect { described_class.new(unknown: 1) }.to raise_error ArgumentError, /Unknown libcurl option: unknown/
+    end
+
+    it 'raises on unknown values' do
+      expect { described_class.new(sslversion: :tlsv9) }.to raise_error ArgumentError, /sslversion: :tlsv9/
+    end
+  end
+
+  describe '#apply' do
+    let(:values) { {followlocation: true, useragent: 'restify', postquote: []} }
+    let(:easy) { instance_double(Restify::Adapter::Ethon::Easy, handle: FFI::Pointer.new(1)) }
+
+    it 'sets converted options directly, and others with the generic handling' do
+      expect(Ethon::Curl).to receive(:easy_setopt).with(easy.handle, number(:followlocation), :long, 1)
+      expect(Ethon::Curl).to receive(:easy_setopt).with(easy.handle, number(:useragent), :string, 'restify')
+      expect(Ethon::Curl).to receive(:set_option).with(:postquote, [], easy.handle)
+
+      options.apply(easy)
+    end
+  end
+
+  describe '.number' do
+    it 'returns the number of the libcurl option' do
+      expect(number(:timeout_ms)).to eq 155
+    end
+
+    it 'raises on unknown options' do
+      expect { number(:unknown) }.to raise_error ArgumentError, /Unknown libcurl option/
+    end
+  end
+end

data/spec/restify/adapter/ethon/pool_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Adapter::Ethon::Pool do
+  subject(:pool) do
+    described_class.new(size: 2) do
+      created << Handle.new(0, Pointer.new(true))
+      created.last
+    end
+  end
+
+  let(:created) { [] }
+
+  before do
+    stub_const('Pointer', Struct.new(:autorelease))
+    stub_const('Handle', Struct.new(:resets, :handle) do
+      def reset
+        self.resets += 1
+      end
+    end,)
+  end
+
+  def release(*handles)
+    handles.each {|handle| pool.release(handle) }
+  end
+
+  describe '#checkout' do
+    it 'creates a handle when none is idle' do
+      expect(pool.checkout).to be created.first
+    end
+
+    it 'reuses released handles' do
+      handle = pool.checkout
+      release(handle)
+
+      expect(pool.checkout).to be handle
+      expect(created.size).to eq 1
+    end
+
+    it 'returns distinct handles to concurrent threads' do
+      release(*Array.new(2) { pool.checkout })
+
+      handles = Array.new(4) { Thread.new { pool.checkout } }.map(&:value)
+
+      expect(handles.map(&:object_id).uniq.size).to eq 4
+    end
+  end
+
+  describe '#release' do
+    it 'resets handles' do
+      handle = pool.checkout
+      release(handle)
+
+      expect(handle.resets).to eq 1
+    end
+
+    it 'keeps a limited number of idle handles' do
+      released = Array.new(3) { pool.checkout }
+      release(*released)
+
+      # Two of them are reused, the third one is created anew.
+      reused = Array.new(3) { pool.checkout }
+
+      expect(reused.count {|handle| released.any? {|r| r.equal?(handle) } }).to eq 2
+      expect(created.size).to eq 4
+    end
+  end
+
+  describe '#forked!' do
+    it 'does not release idle handles' do
+      idle = pool.checkout
+      release(idle)
+
+      pool.forked!
+
+      expect(idle.handle.autorelease).to be false
+      expect(pool.checkout).not_to be idle
+    end
+  end
+end

data/spec/restify/adapter/ethon_spec.rb

@@ -6,87 +6,32 @@ describe Restify::Adapter::Ethon do
   describe 'completed transfers' do
     subject(:value) do
       Restify::Promise.create do |writer|
-        described_class.new.send(
-          :complete,
-          easy,
-          request,
-          writer,
-        )
+        described_class.new.send(:complete, easy, request, writer)
       end.value!
     end
 
     let(:request) { Restify::Request.new(uri: 'http://example.org/base') }
-    let(:return_code) { :ok }
-    let(:response_code) { 200 }
-    let(:effective_url) { 'http://example.org/base' }
-
-    # A transfer is handed back from libcurl with its return code and,
-    # for HTTP, the status code of the response.
-    def easy
-      instance_double(
-        described_class::Easy,
-        return_code:,
-        response_code:,
-        effective_url:,
-        response_headers: "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n",
-        response_body: '{}',
-      )
-    end
+    let(:easy) { instance_double(described_class::Easy, return_code: :ok, response_code: 200) }
 
     it 'fulfills the promise with the response' do
-      expect(value.code).to eq 200
-      expect(value.uri.to_s).to eq 'http://example.org/base'
-    end
-
-    context 'when redirected' do
-      let(:effective_url) { 'http://example.org/other/base' }
+      response = instance_double(Restify::Response)
+      allow(easy).to receive(:response).with(request).and_return(response)
 
-      it 'uses the effective URL as the response URI' do
-        expect(value.uri.to_s).to eq 'http://example.org/other/base'
-      end
+      expect(value).to be response
     end
 
-    context 'when the transfer failed' do
-      let(:return_code) { :couldnt_connect }
-      let(:response_code) { 0 }
+    it 'rejects the promise on network errors' do
+      allow(easy).to receive(:response).and_raise(Restify::NetworkError.new(request, 'kaboom'))
 
-      it 'rejects the promise' do
-        expect { value }.to raise_error Restify::NetworkError, /connect/i
-      end
-    end
-
-    # Non-HTTP protocols are refused before a transfer is started, but
-    # libcurl still reports success with a zero status code whenever no
-    # HTTP status was received, and no status code at all when it cannot
-    # be read back. Neither has a response to process.
-    context 'without an HTTP status' do
-      let(:response_code) { 0 }
-
-      it 'rejects the promise' do
-        expect { value }.to raise_error Restify::NetworkError, /without HTTP status/
-      end
-    end
-
-    context 'with an unavailable HTTP status' do
-      let(:response_code) { nil }
-
-      it 'rejects the promise' do
-        expect { value }.to raise_error Restify::NetworkError, /without HTTP status/
-      end
+      expect { value }.to raise_error Restify::NetworkError, /kaboom/
     end
 
     # Unexpected errors must reject the promise too, as the caller would
     # otherwise keep waiting for it until it times out.
-    context 'when building the response fails' do
-      def easy
-        super.tap do |double|
-          allow(double).to receive(:response_headers).and_raise('kaboom')
-        end
-      end
+    it 'rejects the promise on unexpected errors' do
+      allow(easy).to receive(:response).and_raise('kaboom')
 
-      it 'rejects the promise' do
-        expect { value }.to raise_error 'kaboom'
-      end
+      expect { value }.to raise_error 'kaboom'
     end
   end
 
@@ -135,6 +80,13 @@ describe Restify::Adapter::Ethon do
       expect(adapter.call(request('fast')).value!.code).to eq 200
     end
 
+    it 'can wait again after a timeout' do
+      promise = adapter.call(request('slow'))
+
+      expect { promise.value!(0.1) }.to raise_error Timeout::Error
+      expect(promise.value!(1).code).to eq 200
+    end
+
     it 'processes requests from many threads' do
       threads = Array.new(8) do
         Thread.new do
@@ -180,13 +132,105 @@ describe Restify::Adapter::Ethon do
 
     context 'when waiting from within the event loop' do
       it 'does not run the loop again' do
-        adapter.instance_variable_get(:@loop).acquire(0.1)
+        adapter.instance_variable_get(:@events).instance_variable_get(:@lock).acquire(0.1)
 
         expect(adapter.drive(Restify::Promise.new, Restify::Timeout.new(0.1))).to be false
       end
     end
   end
 
+  describe 'reusing easy handles' do
+    let(:adapter) { described_class.new }
+    let(:root) { Restify.new('http://localhost:9292/echo', adapter:) }
+
+    # Easy handles of completed transfers, in order.
+    let(:handles) { [] }
+
+    before do
+      allow(adapter).to receive(:complete).and_wrap_original do |m, easy, *args|
+        handles << easy
+        m.call(easy, *args)
+      end
+    end
+
+    def echo(method, *, **)
+      JSON.parse(root.send(method, *, **).value!.response.body)
+    end
+
+    it 'reuses the handle of a completed request' do
+      2.times { root.get.value! }
+
+      expect(handles[1]).to be handles[0]
+    end
+
+    it 'does not reuse handles of requests in progress' do
+      Restify::Promise.new(Array.new(2) { root.get }).value!
+
+      expect(handles[1]).not_to be handles[0]
+    end
+
+    # Nothing must leak from one request into the next one.
+    describe 'subsequent requests' do
+      it 'use the method of each request' do
+        %i[post get head put patch delete get].each do |method|
+          response = root.send(method).value!.response
+          next if method == :head
+
+          expect(JSON.parse(response.body)).to include('REQUEST_METHOD' => method.to_s.upcase)
+        end
+      end
+
+      it 'do not send a previous body' do
+        root.post('payload').value!
+
+        expect(echo(:get)).not_to have_key('CONTENT_LENGTH')
+      end
+
+      it 'do not send previous headers' do
+        root.get(headers: {'X-Custom' => 'yes'}).value!
+
+        expect(echo(:get)).not_to have_key('HTTP_X_CUSTOM')
+      end
+
+      it 'receive a body after a HEAD request' do
+        root.head.value!
+
+        expect(root.get.value!.response.body).not_to be_empty
+      end
+    end
+
+    describe 'request bodies' do
+      before { stub_request(:any, 'http://stubserver/body') }
+
+      let(:root) { Restify.new('http://localhost:9292/body', adapter:) }
+
+      %i[post put patch].each do |method|
+        it "sends #{method.upcase} bodies" do
+          root.send(method, 'payload').value!
+          root.send(method, 'other').value!
+
+          expect(a_request(method, 'http://stubserver/body').with(body: 'payload')).to have_been_made.once
+          expect(a_request(method, 'http://stubserver/body').with(body: 'other')).to have_been_made.once
+        end
+      end
+    end
+  end
+
+  describe 'options' do
+    it 'raises on unknown options' do
+      expect { described_class.new(options: {unknown: 1}) }.to raise_error ArgumentError, /Unknown libcurl option/
+    end
+
+    it 'sets options on each request' do
+      adapter = described_class.new(options: {useragent: 'restify-spec'})
+      root = Restify.new('http://localhost:9292/echo', adapter:)
+
+      2.times do
+        expect(JSON.parse(root.get.value!.response.body)).to include('HTTP_USER_AGENT' => 'restify-spec')
+      end
+    end
+  end
+
   describe 'after fork' do
     let(:adapter) { described_class.new }
     let(:connects) { Queue.new }

data/spec/restify/adapter/loop_lock_spec.rb

@@ -13,13 +13,13 @@ describe Restify::Adapter::LoopLock do
   # 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
+    done = Queue.new
     threads << Thread.new do
       yield
-      done.set
+      done << true
       sleep
     end
-    expect(done.wait(1)).to be true
+    expect(done.pop(timeout: 1)).to be true
   end
 
   def elapsed
@@ -47,16 +47,16 @@ describe Restify::Adapter::LoopLock do
     end
 
     it 'waits for another thread to release the loop' do
-      acquired = Concurrent::Event.new
+      acquired = Queue.new
       released = false
       threads << Thread.new do
         lock.acquire(1)
-        acquired.set
+        acquired << true
         sleep 0.1
         released = true
         lock.release
       end
-      expect(acquired.wait(1)).to be true
+      expect(acquired.pop(timeout: 1)).to be true
 
       expect(lock.acquire(1)).to be true
       expect(released).to be true

data/spec/restify/context_spec.rb

@@ -72,6 +72,20 @@ describe Restify::Context do
     end
   end
 
+  describe '#join' do
+    let(:uri) { 'http://localhost/base/' }
+
+    it 'resolves relative URIs' do
+      expect(context.join('../other').to_s).to eq 'http://localhost/other'
+    end
+
+    it 'returns absolute URIs as they are' do
+      absolute = Addressable::URI.parse('http://example.org/path')
+
+      expect(context.join(absolute)).to be absolute
+    end
+  end
+
   describe '#request' do
     subject(:request) { context.request(:get, '/').value! }
 

data/spec/restify/features/opentelemetry_spec.rb

@@ -39,6 +39,8 @@ describe Restify do
       # have the Restify span as a parent.
       spans[0].tap do |span|
         expect(span.instrumentation_scope.name).to include('Ethon')
+        expect(span.name).to eq 'GET'
+        expect(span.attributes).to include('http.request.method' => 'GET')
         expect(span.parent_span_id).to eq spans[1].span_id
       end
     end

data/spec/restify/processors/json_spec.rb

@@ -96,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
@@ -106,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