restify 2.1.0 → 3.0.0.rc3

data/spec/restify/adapter/ethon_spec.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+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)
+      end.value!
+    end
+
+    let(:request) { Restify::Request.new(uri: 'http://example.org/base') }
+    let(:easy) { instance_double(described_class::Easy, return_code: :ok, response_code: 200) }
+
+    it 'fulfills the promise with the response' do
+      response = instance_double(Restify::Response)
+      allow(easy).to receive(:response).with(request).and_return(response)
+
+      expect(value).to be response
+    end
+
+    it 'rejects the promise on network errors' do
+      allow(easy).to receive(:response).and_raise(Restify::NetworkError.new(request, 'kaboom'))
+
+      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.
+    it 'rejects the promise on unexpected errors' do
+      allow(easy).to receive(:response).and_raise('kaboom')
+
+      expect { value }.to raise_error 'kaboom'
+    end
+  end
+
+  describe 'waiting on requests' do
+    let(:adapter) { described_class.new }
+
+    # Threads that completed a transfer, i.e. ran the event loop.
+    let(:completed_by) { Queue.new }
+
+    before do
+      stub_request(:get, 'http://stubserver/fast')
+        .to_return(status: 200, body: '{}')
+      stub_request(:get, 'http://stubserver/slow')
+        .to_return { sleep 0.5 and {status: 200, body: '{}'} }
+
+      allow(adapter).to receive(:complete).and_wrap_original do |m, *args|
+        completed_by << Thread.current
+        m.call(*args)
+      end
+    end
+
+    def request(path)
+      Restify::Request.new(uri: "http://localhost:9292/#{path}")
+    end
+
+    def completed_by_threads
+      Array.new(completed_by.size) { completed_by.pop }
+    end
+
+    it 'runs the event loop in the waiting thread' do
+      expect(adapter.call(request('fast')).value!.code).to eq 200
+      expect(completed_by_threads).to eq [Thread.current]
+    end
+
+    it 'completes requests nobody waits on in the background' do
+      adapter.call(request('fast'))
+
+      # Poll without waiting on the promise:
+      Timeout.timeout(1) { sleep 0.01 while completed_by.empty? }
+
+      expect(completed_by_threads).not_to include Thread.current
+    end
+
+    it 'times out without blocking other requests' do
+      expect { adapter.call(request('slow')).value!(0.1) }.to raise_error Timeout::Error
+      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
+          Array.new(5) { adapter.call(request('fast')).value!.code }
+        end
+      end
+
+      expect(threads.flat_map(&:value)).to all eq 200
+    end
+
+    # Only the adapter's own promises are completed by whichever thread
+    # runs the event loop. Callbacks chained to them must still run in
+    # the thread waiting on them, and only when waiting on them.
+    describe 'chained callbacks' do
+      it 'does not run them before waiting on them' do
+        ran_in = Queue.new
+        promise = adapter.call(request('fast'))
+        chained = promise.then { ran_in << Thread.current }
+
+        promise.value!
+        expect(ran_in).to be_empty
+
+        chained.value!
+        expect(ran_in.pop(timeout: 1)).to eq Thread.current
+      end
+
+      it 'runs them in the waiting thread when another thread runs the loop' do
+        # Keep the loop busy in another thread, until after the fast
+        # request completed.
+        driver = Thread.new { adapter.call(request('slow')).value! }
+        sleep 0.1
+
+        chained = adapter.call(request('fast')).then do |response|
+          [Thread.current, response.code]
+        end
+
+        expect(chained.value!).to eq [Thread.current, 200]
+        expect(completed_by_threads.first).to eq driver
+      ensure
+        driver&.join
+      end
+    end
+
+    context 'when waiting from within the event loop' do
+      it 'does not run the loop again' do
+        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 }
+
+    before do
+      stub_request(:get, 'http://stubserver/fast')
+        .to_return(status: 200, body: '{}')
+      stub_request(:get, 'http://stubserver/slow')
+        .to_return { sleep 0.5 and {status: 200, body: '{}'} }
+
+      allow(adapter).to receive(:complete).and_wrap_original do |m, easy, *args|
+        connects << Ethon::Curl.get_info_long(:num_connects, easy.handle)
+        m.call(easy, *args)
+      end
+    end
+
+    def request(path)
+      Restify::Request.new(uri: "http://localhost:9292/#{path}")
+    end
+
+    def in_child
+      reader, writer = IO.pipe
+
+      pid = fork do
+        reader.close
+        result = begin
+          yield
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          e
+        end
+        writer.write(Marshal.dump(result))
+      ensure
+        # Skip at exit handlers of the parent
+        exit!(0)
+      end
+
+      writer.close
+      Marshal.load(reader.read) # rubocop:disable Security/MarshalLoad
+    ensure
+      reader&.close
+      Process.wait(pid) if pid
+    end
+
+    it 'does not use connections of the parent process' do
+      # The parent process pools and reuses its connection.
+      2.times { adapter.call(request('fast')).value! }
+      expect(Array.new(2) { connects.pop(timeout: 1) }).to eq [1, 0]
+
+      result = in_child do
+        code = adapter.call(request('fast')).value!.code
+        [code, connects.pop(timeout: 1)]
+      end
+
+      # A new connection, not the one pooled by the parent process
+      expect(result).to eq [200, 1]
+
+      # The parent process can still use its connections
+      expect(adapter.call(request('fast')).value!.code).to eq 200
+    end
+
+    it 'rejects requests started before the fork in the child process' do
+      promise = adapter.call(request('slow'))
+
+      result = in_child do
+        promise.value!
+      rescue Restify::NetworkError => e
+        e.message
+      end
+
+      expect(result).to include 'before fork'
+      expect(promise.value!.code).to eq 200
+    end
+  end
+end

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 = Queue.new
+    threads << Thread.new do
+      yield
+      done << true
+      sleep
+    end
+    expect(done.pop(timeout: 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 = Queue.new
+      released = false
+      threads << Thread.new do
+        lock.acquire(1)
+        acquired << true
+        sleep 0.1
+        released = true
+        lock.release
+      end
+      expect(acquired.pop(timeout: 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

@@ -71,4 +71,73 @@ describe Restify::Context do
       it_behaves_like 'serialization'
     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! }
+
+    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

@@ -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/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