restify 3.0.0.rc2 → 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
@@ -118,24 +138,21 @@ describe Restify::Promise do
         end
       end
 
-      context 'when fulfilling the promise asynchronously' do
-        subject(:promise) do
-          described_class.create do |writer|
-            Thread.new do
-              sleep 0.1
-              writer.fulfill 42
-            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
@@ -160,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
         [
@@ -215,7 +249,7 @@ 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
@@ -240,19 +274,16 @@ describe Restify::Promise do
 
       it 'waits as usual when the driver declines' do
         allow(driver).to receive(:drive).and_return(false)
+        waiter = blocking { promise.value! }
 
-        Thread.new do
-          sleep 0.05
-          writer.fulfill 42
-        end
-
-        expect(promise.value!).to eq 42
+        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.1) }.to raise_error Timeout::Error
+        expect { promise.wait(0.01) }.to raise_error Timeout::Error
       end
 
       it 'does not call the driver for a complete promise' do
@@ -264,15 +295,181 @@ describe Restify::Promise do
     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

@@ -28,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} }
 

data/spec/restify/timeout_spec.rb

@@ -5,61 +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 '#remaining' do
-    it 'returns the seconds left' do
-      expect(timer.remaining).to be_within(0.05).of(0.2)
+  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 'is not positive after having timed out' do
-      sleep timer.remaining
-      expect(timer.remaining).not_to be_positive
+    it 'names the duration without a target' do
+      expect(timer.exception.message).to eq 'Operation timed out after 0.2s'
     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 '.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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: restify
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc2
+  version: 3.0.0.rc3
 platform: ruby
 authors:
 - Jan Graichen
@@ -23,20 +23,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.3'
-- !ruby/object:Gem::Dependency
-  name: concurrent-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: ethon
   requirement: !ruby/object:Gem::Requirement
@@ -135,6 +121,10 @@ files:
 - lib/restify.rb
 - lib/restify/adapter/base.rb
 - lib/restify/adapter/ethon.rb
+- lib/restify/adapter/ethon/easy.rb
+- lib/restify/adapter/ethon/event_loop.rb
+- lib/restify/adapter/ethon/options.rb
+- lib/restify/adapter/ethon/pool.rb
 - lib/restify/adapter/loop_lock.rb
 - lib/restify/adapter/telemetry.rb
 - lib/restify/adapter/typhoeus.rb
@@ -158,6 +148,10 @@ files:
 - lib/restify/version.rb
 - lib/restify/webmock.rb
 - spec/restify/adapter/base_spec.rb
+- spec/restify/adapter/ethon/easy_spec.rb
+- spec/restify/adapter/ethon/event_loop_spec.rb
+- spec/restify/adapter/ethon/options_spec.rb
+- spec/restify/adapter/ethon/pool_spec.rb
 - spec/restify/adapter/ethon_spec.rb
 - spec/restify/adapter/loop_lock_spec.rb
 - spec/restify/adapter/telemetry_spec.rb