restify 2.1.0 → 3.0.0.rc3

data/spec/restify/promise_spec.rb

@@ -4,6 +4,26 @@ require 'spec_helper'
 
 describe Restify::Promise do
   let(:promise) { described_class.new }
+  let(:threads) { [] }
+
+  after do
+    threads.each(&:kill).each(&:join)
+  end
+
+  def pending_promise
+    writer = nil
+    promise = described_class.create {|w| writer = w }
+    [promise, writer]
+  end
+
+  # Run the block in another thread, and return once the thread blocks,
+  # e.g. waiting on a promise.
+  def blocking(&)
+    thread = Thread.new(&)
+    threads << thread
+    Thread.pass until thread.stop?
+    thread
+  end
 
   describe 'factory methods' do
     describe '#fulfilled' do
@@ -81,24 +101,58 @@ describe Restify::Promise do
         end
       end
 
-      context 'when fulfilling the promise asynchronously' do
+      context 'when resolving the promise from a block' do
         subject(:promise) do
           described_class.create do |writer|
-            Thread.new do
-              sleep 0.1
-              writer.fulfill 42
-            end
+            writer.set { block.call }
+          end
+        end
+
+        context 'with a returned value' do
+          let(:block) { -> { 42 } }
+
+          it 'fulfills the promise with it' do
+            expect(promise.fulfilled?).to be true
+            expect(promise.value!).to eq 42
+          end
+        end
+
+        context 'with a raised exception' do
+          let(:block) { -> { raise ArgumentError.new('nope') } }
+
+          it 'rejects the promise with it' do
+            expect(promise.rejected?).to be true
+            expect { promise.value! }.to raise_error ArgumentError, 'nope'
           end
         end
 
+        # Handlers can run from e.g. a libcurl callback, from where no
+        # exception must ever escape, not even a non-StandardError.
+        context 'with a raised non-StandardError' do
+          let(:block) { -> { raise NotImplementedError.new('nope') } }
+
+          it 'rejects the promise with it' do
+            expect(promise.rejected?).to be true
+            expect { promise.value! }.to raise_error NotImplementedError, 'nope'
+          end
+        end
+      end
+
+      context 'when fulfilling the promise later' do
         it 'returns a pending promise' do
+          promise, = pending_promise
+
           expect(promise.fulfilled?).to be false
           expect(promise.rejected?).to be false
           expect(promise.pending?).to be true
         end
 
         it 'waits for the fulfillment value' do
-          expect(promise.value!).to eq 42
+          promise, writer = pending_promise
+          waiter = blocking { promise.value! }
+
+          writer.fulfill 42
+          expect(waiter.value).to eq 42
         end
       end
     end
@@ -123,6 +177,23 @@ describe Restify::Promise do
       end
     end
 
+    context 'with a task raising an exception' do
+      let(:task) { proc { raise ArgumentError.new('kaboom') } }
+
+      it 'rejects the promise with it' do
+        expect { result }.to raise_error ArgumentError, 'kaboom'
+      end
+    end
+
+    # No exception must escape from a task, not even a non-StandardError.
+    context 'with a task raising a non-StandardError' do
+      let(:task) { proc { raise NotImplementedError.new('kaboom') } }
+
+      it 'rejects the promise with it' do
+        expect { result }.to raise_error NotImplementedError, 'kaboom'
+      end
+    end
+
     context 'with dependencies, but no task' do
       let(:dependencies) do
         [
@@ -178,19 +249,227 @@ describe Restify::Promise do
 
   describe '#wait' do
     it 'can time out' do
-      expect { promise.wait(0.1) }.to raise_error Timeout::Error
+      expect { promise.wait(0.01) }.to raise_error Timeout::Error
+    end
+
+    context 'with a driver' do
+      subject(:promise) { described_class.create(driver:) {|w| writers << w } }
+
+      let(:driver) { instance_double(Restify::Adapter::Ethon) }
+      let(:writers) { [] }
+      let(:writer) { writers.first }
+
+      before { promise }
+
+      it 'lets the driver complete the promise in the waiting thread' do
+        expect(driver).to receive(:drive).once do |p, timeout|
+          expect(p).to be promise
+          expect(timeout).to be_a Restify::Timeout
+          writer.fulfill 42
+          true
+        end
+
+        expect(promise.value!).to eq 42
+      end
+
+      it 'waits as usual when the driver declines' do
+        allow(driver).to receive(:drive).and_return(false)
+        waiter = blocking { promise.value! }
+
+        writer.fulfill 42
+        expect(waiter.value).to eq 42
+      end
+
+      it 'times out when the driver returns without completing it' do
+        allow(driver).to receive(:drive).and_return(true)
+
+        expect { promise.wait(0.01) }.to raise_error Timeout::Error
+      end
+
+      it 'does not call the driver for a complete promise' do
+        expect(driver).not_to receive(:drive)
+        writer.fulfill 42
+
+        expect(promise.value!).to eq 42
+      end
+    end
+  end
+
+  describe 'timeouts' do
+    it 'uses the default timeout' do
+      previous = Restify::Timeout.default_timeout
+      Restify::Timeout.default_timeout = 0.01
+
+      expect { promise.wait }.to raise_error Restify::Timeout::Error
+    ensure
+      Restify::Timeout.default_timeout = previous
+    end
+
+    it 'does not reject the promise' do
+      dependency, writer = pending_promise
+      chained = dependency.then {|v| v + 1 }
+
+      expect { chained.value!(0.01) }.to raise_error Restify::Timeout::Error
+      expect(chained).to be_pending
+
+      writer.fulfill 1
+      expect(chained.value!).to eq 2
+    end
+
+    it 'does not run the task again after a timeout' do
+      calls = 0
+      inner, writer = pending_promise
+      chained = described_class.fulfilled(1).then do
+        calls += 1
+        inner
+      end
+
+      expect { chained.value!(0.01) }.to raise_error Restify::Timeout::Error
+
+      writer.fulfill 2
+      expect(chained.value!).to eq 2
+      expect(calls).to eq 1
+    end
+
+    it 'times out while another thread runs the task' do
+      dependency, writer = pending_promise
+      chained = dependency.then {|v| v + 1 }
+      running = blocking { chained.value! }
+
+      expect { chained.value!(0.01) }.to raise_error Restify::Timeout::Error
+      expect(running).to be_alive
+
+      writer.fulfill 1
+      expect(running.value).to eq 2
+    end
+
+    # Giving up after a timeout releases the claim the same way.
+    it 'lets a waiting thread take over when the running thread is killed' do
+      dependency, writer = pending_promise
+      chained = dependency.then {|v| v + 1 }
+      running = blocking { chained.value! }
+      waiting = blocking { chained.value! }
+
+      running.kill.join
+
+      writer.fulfill 1
+      expect(waiting.value).to eq 2
+    end
+
+    it 'runs the task once for concurrent waiters' do
+      dependency, writer = pending_promise
+      calls = Queue.new
+      chained = dependency.then {|v| calls << v }
+      waiters = Array.new(5) { blocking { chained.value! } }
+
+      writer.fulfill 1
+      waiters.each(&:join)
+      expect(calls.size).to eq 1
+    end
+  end
+
+  describe '#then' do
+    it 'waits on a promise returned from the task' do
+      chained = described_class.fulfilled(1).then do |v|
+        described_class.fulfilled(v + 1)
+      end
+
+      expect(chained.value!).to eq 2
+    end
+
+    it 'rejects with the reason of a rejected dependency' do
+      chained = described_class.rejected(ArgumentError.new('nope')).then { 42 }
+
+      expect { chained.value! }.to raise_error ArgumentError, 'nope'
+    end
+
+    it 'rejects with the reason of a promise returned from the task' do
+      chained = described_class.fulfilled(1).then do
+        described_class.rejected(ArgumentError.new('nope'))
+      end
+
+      expect { chained.value! }.to raise_error ArgumentError, 'nope'
+    end
+
+    it 'runs lazily' do
+      calls = 0
+      chained = described_class.fulfilled(1).then { calls += 1 }
+
+      expect(calls).to eq 0
+      chained.value!
+      expect(calls).to eq 1
+    end
+  end
+
+  describe '#add_observer' do
+    let(:writers) { [] }
+    let(:promise) { described_class.create {|w| writers << w } }
+    let(:writer) { writers.first }
+
+    before { promise }
+
+    it 'is called when fulfilled' do
+      calls = []
+      promise.add_observer {|value, reason| calls << [value, reason] }
+
+      expect(calls).to eq []
+      writer.fulfill 42
+      expect(calls).to eq [[42, nil]]
+    end
+
+    it 'is called when rejected' do
+      error = ArgumentError.new
+      calls = []
+      promise.add_observer {|value, reason| calls << [value, reason] }
+
+      writer.reject error
+      expect(calls).to eq [[nil, error]]
+    end
+
+    it 'is called right away when already complete' do
+      calls = []
+      writer.fulfill 42
+
+      promise.add_observer {|value, _| calls << value }
+      expect(calls).to eq [42]
+    end
+
+    it 'calls later observers when one raises' do
+      calls = []
+      promise.add_observer { raise 'kaboom' }
+      promise.add_observer {|value, _| calls << value }
+
+      expect { writer.fulfill 42 }.not_to raise_error
+      expect(calls).to eq [42]
+    end
+  end
+
+  describe 'Writer' do
+    let(:writers) { [] }
+    let(:promise) { described_class.create {|w| writers << w } }
+    let(:writer) { writers.first }
+
+    before { promise }
+
+    it 'cannot complete a promise twice' do
+      writer.fulfill 1
+
+      expect { writer.fulfill 2 }.to raise_error Restify::Promise::AlreadyCompleteError
+      expect { writer.reject ArgumentError }.to raise_error Restify::Promise::AlreadyCompleteError
+      expect { writer.set { 2 } }.to raise_error Restify::Promise::AlreadyCompleteError
+      expect(promise.value!).to eq 1
     end
   end
 
   describe '#value' do
     it 'can time out' do
-      expect { promise.value(0.1) }.to raise_error Timeout::Error
+      expect { promise.value(0.01) }.to raise_error Timeout::Error
     end
   end
 
   describe '#value!' do
     it 'can time out' do
-      expect { promise.value!(0.1) }.to raise_error Timeout::Error
+      expect { promise.value!(0.01) }.to raise_error Timeout::Error
     end
   end
 end

data/spec/restify/relation_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'active_support'
 
 describe Restify::Relation do
   subject(:relation) { described_class.new context, pattern }
@@ -29,6 +28,29 @@ describe Restify::Relation do
 
     it { is_expected.to be_a Addressable::URI }
 
+    context 'without template variables' do
+      let(:pattern) { '/resource?a=1' }
+      let(:params) { {} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource?a=1' }
+
+      it 'reuses a frozen URI' do
+        expect(expanded).to be_frozen
+        expect(relation.expand({})).to be expanded
+      end
+
+      context 'with query parameters' do
+        let(:params) { {b: 2} }
+
+        it { expect(expanded.to_s).to eq 'http://test.host/resource?a=1&b=2' }
+
+        it 'does not change the reused URI' do
+          expanded
+          expect(relation.expand({}).to_s).to eq 'http://test.host/resource?a=1'
+        end
+      end
+    end
+
     context 'with nil' do
       let(:params) { {id: nil} }
 
@@ -48,11 +70,8 @@ describe Restify::Relation do
     end
 
     context 'with Object' do
-      let(:object) do
-        Class.new do
-          undef to_param
-        end.new
-      end
+      # Without #to_param, e.g. from ActiveSupport
+      let(:object) { Class.new.new }
       let(:params) { {id: object} }
 
       it 'raise a TypeError from adressable' do

data/spec/restify/request_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Request do
+  subject(:request) { described_class.new(uri:) }
+
+  describe '#uri' do
+    context 'with a string' do
+      let(:uri) { 'https://example.org:8443/resources?page=2' }
+
+      it 'parses it' do
+        expect(request.uri).to be_a Addressable::URI
+        expect(request.uri.to_s).to eq uri
+      end
+    end
+
+    context 'with an Addressable::URI' do
+      let(:uri) { Addressable::URI.parse('https://example.org/resources') }
+
+      it 'keeps it as is' do
+        expect(request.uri).to be uri
+      end
+    end
+  end
+end

data/spec/restify/timeout_spec.rb

@@ -5,50 +5,60 @@ require 'spec_helper'
 describe Restify::Timeout do
   let(:timer) { described_class.new(0.2) }
 
-  describe '#timeout!' do
-    context 'before having timed out' do
-      it 'do nothing' do
-        expect { timer.timeout! }.not_to raise_error
-      end
+  describe '#remaining' do
+    it 'returns the seconds left' do
+      expect(timer.remaining).to be_within(0.05).of(0.2)
     end
 
-    context 'after having timed out' do
-      it 'calls given block' do
-        expect { timer.timeout! }.not_to raise_error
-        sleep timer.send(:wait_interval)
-        expect { timer.timeout! }.to raise_error Restify::Timeout::Error
-      end
+    it 'is not positive after having timed out' do
+      expired = described_class.new(0.01)
+      sleep expired.remaining
+
+      expect(expired.remaining).not_to be_positive
     end
   end
 
-  describe '#wait_on!' do
-    it 'calls block on IVar timeout' do
-      expect do
-        timer.wait_on!(Concurrent::IVar.new)
-      end.to raise_error Restify::Timeout::Error
+  describe '#exception' do
+    it 'names the target and duration' do
+      error = described_class.new(0.2, :target).exception
+
+      expect(error).to be_a Restify::Timeout::Error
+      expect(error.target).to eq :target
+      expect(error.duration).to eq 0.2
+      expect(error.message).to eq 'Operation on target timed out after 0.2s'
+    end
+
+    it 'names the duration without a target' do
+      expect(timer.exception.message).to eq 'Operation timed out after 0.2s'
+    end
+  end
+
+  describe '.new' do
+    it 'returns a given timeout' do
+      expect(described_class.new(timer)).to be timer
+    end
+
+    it 'uses the default timeout for nil' do
+      expect(described_class.new(nil).duration).to eq described_class.default_timeout
+    end
+
+    it 'accepts numeric strings' do
+      expect(described_class.new('0.2').duration).to eq 0.2
     end
 
-    it 'calls block on Promise timeout' do
-      expect do
-        timer.wait_on!(Restify::Promise.new)
-      end.to raise_error Restify::Timeout::Error
+    it 'rejects infinite values' do
+      expect { described_class.new(Float::INFINITY) }.to raise_error ArgumentError, /must be finite/
     end
 
-    it 'does nothing on successful IVar' do
-      expect do
-        Concurrent::IVar.new.tap do |ivar|
-          Thread.new { ivar.set :success }
-          expect(timer.wait_on!(ivar)).to eq :success
-        end
-      end.not_to raise_error
+    it 'rejects non-numeric values' do
+      expect { described_class.new('soon') }.to raise_error ArgumentError, /must be a number/
+      expect { described_class.new(Object.new) }.to raise_error ArgumentError, /must be a number/
     end
 
-    it 'does nothing on successful Promise' do
-      expect do
-        Restify::Promise.fulfilled(:success).tap do |p|
-          expect(timer.wait_on!(p)).to eq :success
-        end
-      end.not_to raise_error
+    it 'rejects non-positive values' do
+      expect { described_class.new(0) }.to raise_error ArgumentError, /must be > 0/
+      expect { described_class.new(-1) }.to raise_error ArgumentError, /must be > 0/
+      expect { described_class.new(Float::NAN) }.to raise_error ArgumentError, /must be > 0/
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require 'logger'
 require 'rspec'
 
 require 'simplecov'
 require 'simplecov-cobertura'
 
 SimpleCov.start do
-  add_filter 'spec'
+  skip %r{\Aspec/}i
 end
 
 SimpleCov.formatters = [
@@ -18,6 +19,9 @@ require 'restify'
 
 if ENV['ADAPTER']
   case ENV['ADAPTER'].to_s.downcase
+    when 'ethon'
+      require 'restify/adapter/ethon'
+      Restify.adapter = Restify::Adapter::Ethon.new
     when 'typhoeus'
       require 'restify/adapter/typhoeus'
       Restify.adapter = Restify::Adapter::Typhoeus.new
@@ -32,6 +36,8 @@ end
 require_relative 'support/opentelemetry'
 require_relative 'support/stub_server'
 
+require 'restify/webmock'
+
 RSpec.configure do |config|
   config.order = 'random'
 
@@ -46,11 +52,9 @@ RSpec.configure do |config|
     skip 'Spec not enabled for current adapter'
   end
 
-  config.before do
-    Ethon.logger = Logging.logger[Ethon] if defined?(Ethon)
-
-    Logging.logger.root.level = :debug
-    Logging.logger.root.add_appenders Logging.appenders.stdout
+  config.before(:suite) do
+    Restify.logger = Logger.new($stdout, level: ENV.fetch('LOG_LEVEL', 'debug'))
+    Ethon.logger = Restify.logger
   end
 
   config.warnings = true

data/spec/support/stub_server.rb

@@ -65,8 +65,8 @@ module Stub
 
   class Exception < ::StandardError; end
 
-  # Inject into base adapter to have HTTP 599 (missing stub) error raised as an
-  # extra exception, not just a server error.
+  # Inject into base adapter to have HTTP 599 (missing stub) error
+  # raised as an extra exception, not just a server error.
   module Patch
     def call(request)
       super.then do |response|
@@ -98,8 +98,8 @@ RSpec.configure do |config|
   config.before(:suite) do
     Stub.start_server!
 
-    # Net::HTTP adapter must be enabled, otherwise webmock fails to create mock
-    # responses from raw strings.
+    # Net::HTTP adapter must be enabled, otherwise webmock fails to
+    # create mock responses from raw strings.
     WebMock.disable!(except: %i[net_http])
   end