promise_pool 0.1.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba178cdd8145f5c65340a8599ffc9dbd4775ccef
-  data.tar.gz: a978b9d5072e8038f9cb2e6884432bc9e4f0a6ac
+  metadata.gz: 8cdae0e0cfd7f377206d08c5898bc2637a4eca77
+  data.tar.gz: a7a4f91c93b6b81fa4c1472772d445b43ff2764e
 SHA512:
-  metadata.gz: d531803ba5e8d28b438da3d152e8315ba7ce0de796ee781bcf0f0c2de23f7bf598bed2e9693d548ed05414cd8bd623b34f754588b1cb4ac3ac2bdf4dc898848e
-  data.tar.gz: 406aa62fec4d02adf8eaf0088a0ed8ac7e08a70cf147d01c8ab7d41cbc588541385ff4a1633d18fb3c6e848860a4cb7f9f28c9b8c361f358006071c0954b0257
+  metadata.gz: 9d0c873467132e5132e83ecb6f000baed9acc44c282fe02b39455f56a3b6db6222803f65e82e12501e5c7f717c683166bbcfb917a4101736610ceb43bbc98e9d
+  data.tar.gz: 1143bb7a1a4438909b3efe14471012638168cb920a18d00d6644aeafe0ad4652d6e904f33023b97adcc90b66a5c6652d56bb13f5c0714ea10cb88fc25d49e1f7

data/CHANGES.md

@@ -0,0 +1,9 @@
+# CHANGES
+
+## promise_pool 0.9.0 -- 2016-01-29
+
+* First beta!
+
+## promise_pool 0.5.0 -- 2016-01-26
+
+* Birthday!

data/README.md

@@ -10,15 +10,21 @@ by Lin Jen-Shin ([godfat](http://godfat.org))
 
 ## DESCRIPTION:
 
-promise_pool
+promise_pool is a promise implementation backed by threads or threads pool.
 
 ## FEATURES:
 
-* promise_pool
+* PromisePool::Promise
+* PromisePool::ThreadPool
+* PromisePool::Timer
 
 ## WHY?
 
-promise_pool
+This was extracted from [rest-core][] because rest-core itself is getting
+too complex, and extracting promises from it could greatly reduce complexity
+and improve modularity for both rest-core and promise_pool.
+
+* [rest-core]: https://github.com/godfat/rest-core
 
 ## REQUIREMENTS:
 
@@ -40,6 +46,135 @@ gem 'promise_pool', :git => 'git://github.com/godfat/promise_pool.git',
                     :submodules => true
 ```
 
+## SYNOPSIS:
+
+### Basic Usage
+
+``` ruby
+require 'promise_pool/promise'
+promise = PromisePool::Promise.new
+promise.defer do
+  sleep 1
+  puts "Doing works..."
+  sleep 1
+  "Done!"
+end
+puts "It's not blocking!"
+puts promise.yield
+```
+
+Prints:
+
+```
+It's not blocking!
+Doing works...
+Done!
+```
+
+### Multiple Concurrent Promises
+
+Doing multiple things at the same time, and wait for all of them at once.
+
+``` ruby
+require 'promise_pool/promise'
+
+futures = 3.times.map do |i|
+  PromisePool::Promise.new.defer do
+    sleep i
+    i
+  end.future
+end
+
+futures.each(&method(:puts))
+```
+
+Prints:
+
+```
+0
+1
+2
+```
+
+### Error Handling
+
+If an exception was raised in the `defer` block, it would propagate whenever
+`yield` is called. Note that futures would implicitly call `yield` for you.
+
+``` ruby
+require 'promise_pool/promise'
+
+future = PromisePool::Promise.new.defer do
+  raise 'nnf'
+end.future
+
+begin
+  future.to_s
+  never reached
+rescue RuntimeError => e
+  puts e
+end
+```
+
+Prints:
+
+```
+nnf
+```
+
+### PromisePool::ThreadPool
+
+With a thread pool, we could throttle the process and avoid exhausting
+resources whenever needed.
+
+``` ruby
+require 'promise_pool/promise'
+require 'promise_pool/thread_pool'
+
+pool = PromisePool::ThreadPool.new(10, 60) # max_size=10, idle_time=60
+future = PromisePool::Promise.new.defer(pool) do
+  'Only process this whenever a worker is available.'
+end.future
+
+puts future
+
+pool.shutdown # Make sure all the tasks are done in the pool before exit.
+              # You'll surely need this for shutting down gracefully.
+```
+
+Prints:
+
+```
+Only process this whenever a worker is available.
+```
+
+### PromisePool::Timer
+
+If a task is taking too much time, we could time it out.
+
+``` ruby
+require 'promise_pool/promise'
+require 'promise_pool/timer'
+
+timer = PromisePool::Timer.new(1)
+future = PromisePool::Promise.new(timer).defer do
+  sleep
+  never reached
+end.future
+
+begin
+  future.to_s
+rescue PromisePool::Timer::Error => e
+  puts e.message
+end
+```
+
+Prints:
+
+```
+execution expired
+```
+
 ## CHANGES:
 
 * [CHANGES](CHANGES.md)

data/Rakefile

@@ -2,7 +2,7 @@
 begin
   require "#{dir = File.dirname(__FILE__)}/task/gemgem"
 rescue LoadError
-  sh 'git submodule update --init'
+  sh 'git submodule update --init --recursive'
   exec Gem.ruby, '-S', $PROGRAM_NAME, *ARGV
 end
 

data/lib/promise_pool/future.rb

@@ -8,5 +8,9 @@ module PromisePool
     def method_missing msg, *args, &block
       @promise.yield.__send__(msg, *args, &block)
     end
+
+    def respond_to_missing? msg, *args, &block
+      @promise.yield.respond_to?(msg, *args, &block)
+    end
   end
 end

data/lib/promise_pool/promise.rb

@@ -4,8 +4,9 @@ require 'promise_pool/future'
 
 module PromisePool
   class Promise
-    def self.claim value
+    def self.claim value, &callback
       promise = new
+      promise.then(&callback) if block_given?
       promise.fulfill(value)
       promise
     end
@@ -21,9 +22,9 @@ module PromisePool
 
     def initialize timer=nil
       self.value = self.error = self.result = nil
-      self.resolved = self.called = false
+      self.resolved = false
+      self.callbacks = []
 
-      self.k     = []
       self.timer = timer
       self.condv = ConditionVariable.new
       self.mutex = Mutex.new
@@ -54,6 +55,7 @@ module PromisePool
     def call
       self.thread = Thread.current # set working thread
       protected_yield{ yield } # avoid any exception and do the job
+      self
     end
 
     def future
@@ -69,7 +71,12 @@ module PromisePool
     # called in client thread (from the future (e.g. body))
     def yield
       wait
-      mutex.synchronize{ callback }
+      case result
+      when Exception
+        raise result
+      else
+        result
+      end
     end
 
     # called in requesting thread after the request is done
@@ -84,7 +91,7 @@ module PromisePool
 
     # append your actions, which would be called when we're calling back
     def then &action
-      k << action
+      callbacks << action
       self
     end
 
@@ -93,24 +100,28 @@ module PromisePool
     end
 
     protected
-    attr_accessor :value, :error, :result, :resolved, :called,
-                  :k, :timer, :condv, :mutex, :task, :thread
+    attr_accessor :value, :error, :result, :resolved, :callbacks,
+                  :timer, :condv, :mutex, :task, :thread
 
     private
-    def fulfilling value
+    def fulfilling value # should be synchronized
       self.value = value
       resolve
     end
 
-    def rejecting error
+    def rejecting error # should be synchronized
       self.error = error
       resolve
     end
 
-    def resolve
-      self.resolved = true
-      yield if block_given?
+    def resolve # should be synchronized
+      self.result = callbacks.inject(error || value){ |r, k| k.call(r) }
+    rescue Exception => err
+      self.class.set_backtrace(err)
+      self.result = err
+      log_callback_error(err)
     ensure
+      self.resolved = true
       condv.broadcast # client or response might be waiting
     end
 
@@ -130,20 +141,12 @@ module PromisePool
 
     def timeout_protected_yield
       # timeout might already be set for thread_pool (pool_size > 0)
-      timer.on_timeout{ cancel_task } unless timer
+      timer.on_timeout{ cancel_task } unless timer.timer
       yield
     ensure
       timer.cancel
     end
 
-    # called in client thread, when yield is called
-    def callback
-      return result if called
-      self.result = k.inject(error || value){ |r, i| i.call(r) }
-    ensure
-      self.called = true
-    end
-
     # timeout!
     def cancel_task
       mutex.synchronize do
@@ -159,5 +162,12 @@ module PromisePool
         end
       end
     end
+
+    # log user callback error, should never raise
+    def log_callback_error err
+      warn "#{self.class}: ERROR: #{err}\n  from #{err.backtrace.inspect}"
+    rescue Exception => e
+      Thread.main.raise(e) if !!$DEBUG
+    end
   end
 end

data/lib/promise_pool/thread_pool.rb

@@ -9,7 +9,7 @@ require 'promise_pool/task'
 module PromisePool
   class ThreadPool
     attr_reader :workers
-    attr_accessor :idle_time, :max_size
+    attr_accessor :max_size, :idle_time
 
     def initialize max_size, idle_time=60
       @max_size  = max_size

data/lib/promise_pool/timer.rb

@@ -4,6 +4,8 @@ require 'timers'
 
 module PromisePool
   class Timer
+    Error = Class.new(RuntimeError)
+
     @mutex = Mutex.new
     @interval = 1
 
@@ -31,16 +33,14 @@ module PromisePool
     end
 
     attr_accessor :timeout, :error, :timer
-    def initialize timeout, error, &block
+    def initialize timeout, error=Error.new('execution expired')
       self.timeout = timeout
       self.error   = error
-      self.block   = block
-      start if block_given?
     end
 
     def on_timeout &block
       self.block = block
-      start if block_given?
+      start
     end
 
     # should never raise!

data/lib/promise_pool/version.rb

@@ -1,4 +1,4 @@
 
 module PromisePool
-  VERSION = '0.1.0'
+  VERSION = '0.9.0'
 end

data/lib/promise_pool.rb

@@ -1,5 +1,4 @@
 
 require 'promise_pool/promise'
-require 'promise_pool/promise_eager'
 require 'promise_pool/thread_pool'
 require 'promise_pool/timer'

data/promise_pool.gemspec

@@ -1,27 +1,27 @@
 # -*- encoding: utf-8 -*-
-# stub: promise_pool 0.1.0 ruby lib
+# stub: promise_pool 0.9.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "promise_pool"
-  s.version = "0.1.0"
+  s.version = "0.9.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2016-01-21"
-  s.description = "promise_pool"
+  s.date = "2016-01-29"
+  s.description = "promise_pool is a promise implementation backed by threads or threads pool."
   s.email = ["godfat (XD) godfat.org"]
   s.files = [
   ".gitignore",
   ".gitmodules",
   ".travis.yml",
+  "CHANGES.md",
   "Gemfile",
   "README.md",
   "Rakefile",
   "lib/promise_pool.rb",
   "lib/promise_pool/future.rb",
   "lib/promise_pool/promise.rb",
-  "lib/promise_pool/promise_eager.rb",
   "lib/promise_pool/queue.rb",
   "lib/promise_pool/task.rb",
   "lib/promise_pool/test.rb",
@@ -31,18 +31,20 @@ Gem::Specification.new do |s|
   "promise_pool.gemspec",
   "task/README.md",
   "task/gemgem.rb",
-  "test/test_pool.rb",
+  "test/test_future.rb",
   "test/test_promise.rb",
-  "test/test_promise_eager.rb",
+  "test/test_readme.rb",
+  "test/test_thread_pool.rb",
   "test/test_timer.rb"]
   s.homepage = "https://github.com/godfat/promise_pool"
   s.licenses = ["Apache License 2.0"]
   s.rubygems_version = "2.5.1"
-  s.summary = "promise_pool"
+  s.summary = "promise_pool is a promise implementation backed by threads or threads pool."
   s.test_files = [
-  "test/test_pool.rb",
+  "test/test_future.rb",
   "test/test_promise.rb",
-  "test/test_promise_eager.rb",
+  "test/test_readme.rb",
+  "test/test_thread_pool.rb",
   "test/test_timer.rb"]
 
   if s.respond_to? :specification_version then

data/test/test_future.rb

@@ -0,0 +1,26 @@
+
+require 'promise_pool/test'
+
+describe PromisePool::Future do
+  would 'return the value' do
+    Promise.new.defer{ 'value' }.future.should.eq 'value'
+  end
+
+  would 'raise an exception' do
+    expect.raise(RuntimeError) do
+      Promise.new.defer do
+        raise 'nnf'
+      end.future.oops
+    end.message.should.eq 'nnf'
+  end
+
+  would 'raise an exception if it is returning an exception' do
+    expect.raise(RuntimeError) do
+      Promise.new.defer{ RuntimeError.new('nnf') }.future.oops
+    end.message.should.eq 'nnf'
+  end
+
+  would 'respond_to_missing? properly' do
+    [Promise.new.defer{0}.future].flatten.first.should.eq 0
+  end
+end

data/test/test_promise.rb

@@ -2,33 +2,141 @@
 require 'promise_pool/test'
 
 describe PromisePool::Promise do
-  would 'claim' do
-    value = 'body'
-    Promise.claim(value).future.should.eq value
+  describe 'claim' do
+    would 'without block' do
+      value = 'body'
+      Promise.claim(value).yield.should.eq value
+    end
+
+    would 'with block' do
+      value = 'body'
+      Promise.claim(value, &:reverse).yield.should.eq 'ydob'
+    end
   end
 
-  would 'then then then' do
-    plusone = lambda{ |r| r + 1 }
-    promise = Promise.new
-    2.times{ promise.then(&plusone).then(&plusone).then(&plusone) }
-    promise.fulfill(0)
-    promise.future.should.eq 6
+  describe 'then' do
+    describe 'with mock' do
+      after do
+        Muack.verify
+      end
+
+      would 'handle exceptions in callbacks' do
+        errors = []
+        promise = Promise.new.then(&errors.method(:<<))
+
+        mock(promise).warn(is_a(String)) do |msg|
+          msg.should.start_with?("PromisePool::Promise: ERROR: nnf\n")
+        end
+
+        promise.then do |es|
+          es.first.message.should.eq 'boom'
+          raise 'nnf'
+        end
+
+        promise.defer do
+          raise 'boom'
+        end.wait
+
+        errors.map(&:message).should.eq ['boom']
+      end
+    end
+
+    would 'then then then' do
+      plusone = lambda{ |r| r + 1 }
+      promise = Promise.new
+      2.times{ promise.then(&plusone).then(&plusone).then(&plusone) }
+      promise.fulfill(0)
+      promise.yield.should.eq 6
+    end
+
+    would 'transform to an exception and raise it' do
+      promise = Promise.new
+      promise.then(&RuntimeError.method(:new))
+      promise.defer{ 'nnf' }
+      expect.raise(RuntimeError) do
+        promise.yield
+      end.message.should.eq 'nnf'
+    end
   end
 
-  after do
-    Muack.verify
+  describe 'call' do
+    would 'call in the current thread' do
+      promise = Promise.new
+      promise.call{ raise 'nnf' }
+      promise.send(:thread).should.eq Thread.current
+      promise.send(:task)  .should.eq nil
+      promise.send(:error).message.should.eq 'nnf'
+      expect.raise(RuntimeError) do
+        promise.yield
+      end.message.should.eq 'nnf'
+    end
   end
 
-  would 'call in a new thread if no pool' do
-    thread = nil
-    rd, wr = IO.pipe
-    mock(Thread).new.with_any_args.peek_return do |t|
-      thread = t
-      wr.puts
-    end
-    Promise.new.defer do
-      rd.gets
-      Thread.current.should.eq thread
-    end.yield
+  describe 'defer' do
+    describe 'with mock' do
+      after do
+        Muack.verify
+      end
+
+      would 'call in a new thread if no pool' do
+        thread = nil
+        rd, wr = IO.pipe
+        mock(Thread).new.with_any_args.peek_return do |t|
+          thread = t
+          wr.puts
+        end
+        Promise.new.defer do
+          rd.gets
+          Thread.current.should.eq thread
+        end.yield
+      end
+    end
+
+    would 'work, fulfill, yield' do
+      value = 'body'
+      flag = 0
+      promise = Promise.new.defer do
+        flag.should.eq 0
+        flag += 1
+        value
+      end
+      promise.yield.should.eq value
+      promise.send(:value).should.eq value
+      promise.send(:result).should.eq value
+      promise.should.resolved?
+      flag.should.eq 1
+    end
+
+    would 'work, reject, wait' do
+      flag = 0
+      promise = Promise.new.defer do
+        flag.should.eq 0
+        flag += 1
+        raise 'boom'
+      end
+      promise.wait
+      flag.should.eq 1
+      promise.send(:error).message.should.eq 'boom'
+    end
+  end
+
+  describe 'wait' do
+    would 'broadcast to different threads' do
+      flag = 0
+      mutex = Mutex.new
+      promise = Promise.new
+      threads = 3.times.map do
+        Thread.new do
+          mutex.synchronize{ flag += 1 }
+          promise.wait
+          mutex.synchronize{ flag += 1 }
+          promise.yield
+        end
+      end
+      Thread.pass until flag == 3
+      promise.fulfill('ok')
+      Thread.pass until flag == 6
+      threads.map(&:value).should.eq %w[ok ok ok]
+    end
   end
 end

data/test/test_readme.rb

@@ -0,0 +1,30 @@
+
+require 'promise_pool/test'
+
+describe 'README.md' do
+  readme = File.read("#{__dir__}/../README.md")
+  codes  = readme.scan(
+    /### ([^\n]+).+?``` ruby\n(.+?)\n```\n\nPrints:\n\n```\n(.+?)```/m)
+
+  context = Class.new(Struct.new(:result)) do
+    def sleep sec=nil
+      if sec
+        Kernel.sleep(sec / 100.0)
+      else
+        Kernel.sleep
+      end
+    end
+
+    def puts str
+      result << "#{str}\n"
+    end
+  end
+
+  codes.each.with_index do |(title, code, test), index|
+    would "pass README.md #%02d #{title}" % index do
+      ctx = context.new([])
+      ctx.instance_eval(code, 'README.md', 0)
+      ctx.result.should.eq test.lines
+    end
+  end
+end

data/test/test_thread_pool.rb

@@ -0,0 +1,50 @@
+
+require 'promise_pool/test'
+
+describe PromisePool::ThreadPool do
+  before do
+    @pool = ThreadPool.new(1)
+    @promise = Promise.new
+  end
+
+  after do
+    @pool.shutdown
+    @pool.size.should.eq 0
+  end
+
+  def defer &block
+    @promise.defer(@pool, &block)
+  end
+
+  would 'use the pool if passed' do
+    @pool.size.should.eq 0
+    defer do
+      @pool.size
+    end.yield.should.eq 1
+  end
+
+  would 'call in thread pool if pool_size > 0' do
+    flag = 0
+    rd, wr = IO.pipe
+    defer do
+      rd.gets
+      flag.should.eq 0
+      flag += 1
+      raise 'nnf'
+    end
+    p1 = Promise.new
+    p1.defer(@pool) do # block until promise #0 is done because max_size == 1
+      flag.should.eq 1
+      flag += 1
+      raise 'boom'
+    end
+    wr.puts # start promise #0
+
+    # even if we're not yielding, the block should still be resolved,
+    # so there should not have any deadlock here.
+    expect.raise(RuntimeError){       p1.yield }.message.should.eq 'boom'
+    expect.raise(RuntimeError){ @promise.yield }.message.should.eq 'nnf'
+
+    flag.should.eq 2
+  end
+end

data/test/test_timer.rb

@@ -2,4 +2,64 @@
 require 'promise_pool/test'
 
 describe PromisePool::Timer do
+  before do
+    @timer = Timer.new(0.01)
+  end
+
+  def expect_raise
+    expect.raise(@timer.error.class) do
+      yield
+    end.should.eq @timer.error
+  end
+
+  would 'raise timeout if task has not started' do
+    pool = ThreadPool.new(0)
+    expect_raise do
+      Promise.new(@timer).defer(pool) do
+        never called
+      end.yield
+    end
+  end
+
+  describe 'with flag' do
+    before do
+      @flag = false
+    end
+
+    after do
+      @flag.should.eq true
+    end
+
+    would 'raise timeout if the task started' do
+      pool = ThreadPool.new(1)
+      expect_raise do
+        Promise.new(@timer).defer(pool) do
+          @flag = true
+          sleep
+          never called
+        end.yield
+      end
+      pool.shutdown
+    end
+
+    would 'raise timeout in the thread' do
+      expect_raise do
+        Promise.new(@timer).defer do
+          @flag = true
+          sleep
+          never called
+        end.yield
+      end
+    end
+
+    would 'raise timeout even with inline call' do
+      expect_raise do
+        Promise.new(@timer).call do
+          @flag = true
+          sleep
+          never called
+        end.yield
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: promise_pool
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-21 00:00:00.000000000 Z
+date: 2016-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: timers
@@ -24,7 +24,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.1
-description: promise_pool
+description: promise_pool is a promise implementation backed by threads or threads
+  pool.
 email:
 - godfat (XD) godfat.org
 executables: []
@@ -34,13 +35,13 @@ files:
 - ".gitignore"
 - ".gitmodules"
 - ".travis.yml"
+- CHANGES.md
 - Gemfile
 - README.md
 - Rakefile
 - lib/promise_pool.rb
 - lib/promise_pool/future.rb
 - lib/promise_pool/promise.rb
-- lib/promise_pool/promise_eager.rb
 - lib/promise_pool/queue.rb
 - lib/promise_pool/task.rb
 - lib/promise_pool/test.rb
@@ -50,9 +51,10 @@ files:
 - promise_pool.gemspec
 - task/README.md
 - task/gemgem.rb
-- test/test_pool.rb
+- test/test_future.rb
 - test/test_promise.rb
-- test/test_promise_eager.rb
+- test/test_readme.rb
+- test/test_thread_pool.rb
 - test/test_timer.rb
 homepage: https://github.com/godfat/promise_pool
 licenses:
@@ -77,9 +79,10 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: promise_pool
+summary: promise_pool is a promise implementation backed by threads or threads pool.
 test_files:
-- test/test_pool.rb
+- test/test_future.rb
 - test/test_promise.rb
-- test/test_promise_eager.rb
+- test/test_readme.rb
+- test/test_thread_pool.rb
 - test/test_timer.rb

data/lib/promise_pool/promise_eager.rb

@@ -1,36 +0,0 @@
-
-require 'promise_pool/promise'
-
-module PromisePool
-  class PromiseEager < Promise
-    attr_accessor :error_callback
-
-    def initialize timer=nil, &error_callback
-      super(timer)
-      self.error_callback = error_callback
-    end
-
-    def resolved?
-      super && called
-    end
-
-    private
-    def resolve
-      super{ callback } # under ASYNC callback, should call immediately
-    rescue Exception => err
-      self.class.set_backtrace(err)
-      call_error_callback(err)
-    end
-
-    # log user callback error, should never raise
-    def call_error_callback err
-      if error_callback
-        error_callback.call(err)
-      else
-        warn "#{self.class}: ERROR: #{err}\n  from #{err.backtrace.inspect}"
-      end
-    rescue Exception => e
-      Thread.main.raise(e) if !!$DEBUG
-    end
-  end
-end

data/test/test_pool.rb

@@ -1,74 +0,0 @@
-
-require 'promise_pool/test'
-
-describe PromisePool::ThreadPool do
-  before do
-    @pool = ThreadPool.new(3)
-    @promise = Promise.new
-  end
-
-  after do
-    @pool.shutdown
-    @pool.size.should.eq 0
-  end
-
-  would 'work, reject, yield' do
-    @pool.max_size = 1
-    flag = 0
-    @promise.defer(@pool) do
-      flag.should.eq 0
-      flag += 1
-      raise 'boom'
-    end.yield
-    flag.should.eq 1
-    @promise.send(:error).message.should.eq 'boom'
-  end
-
-  would 'work, fulfill, yield' do
-    value = 'body'
-    @pool.max_size = 2
-    flag = 0
-    @promise.defer(@pool) do
-      flag.should.eq 0
-      flag += 1
-      value
-    end
-    @promise.future.should.eq value
-    @promise.send(:value).should.eq value
-    @promise.send(:result).should.eq value
-    @promise.should.resolved?
-    flag.should.eq 1
-  end
-
-  would 'work, check body', :groups => [:only] do
-    flag = 0
-    result = @promise.defer(@pool) do
-      flag.should.eq 0
-      flag += 1
-    end.future
-    result.should.eq 1
-    flag.should.eq 1
-  end
-
-  would 'call in thread pool if pool_size > 0' do
-    @pool.max_size = 1
-    flag = 0
-    rd, wr = IO.pipe
-    @promise.defer(@pool) do
-      rd.gets
-      flag.should.eq 0
-      flag += 1
-      raise 'nnf'
-    end
-    p1 = Promise.new
-    p1.defer(@pool) do # block until promise #0 is done because max_size == 1
-      flag.should.eq 1
-      flag += 1
-      raise 'boom'
-    end
-    wr.puts  # start promise #0
-    @promise.yield
-    p1.yield # block until promise #1 is done
-    flag.should.eq 2
-  end
-end

data/test/test_promise_eager.rb

@@ -1,41 +0,0 @@
-
-require 'promise_pool/test'
-
-describe PromisePool::PromiseEager do
-  would 'call error_callback on errors' do
-    errors = []
-    promise = PromiseEager.new(&errors.method(:<<))
-
-    promise.then do |err|
-      err.message.should.eq 'boom'
-      raise 'nnf'
-    end
-
-    promise.defer do
-      raise 'boom'
-    end.wait
-
-    errors.map(&:message).should.eq ['nnf']
-  end
-
-  after do
-    Muack.verify
-  end
-
-  would 'warn if there is no error_callback' do
-    promise = PromiseEager.new
-
-    mock(promise).warn(is_a(String)) do |msg|
-      msg.should.start_with?("PromisePool::PromiseEager: ERROR: nnf\n")
-    end
-
-    promise.then do |value|
-      value.should.eq 'value'
-      raise 'nnf'
-    end
-
-    promise.defer do
-      'value'
-    end.wait
-  end
-end