concurrent-ruby 0.2.2 → 0.3.0.pre.1

data/spec/concurrent/cached_thread_pool_spec.rb

@@ -5,28 +5,27 @@ module Concurrent
 
   describe CachedThreadPool do
 
-    subject { CachedThreadPool.new }
+    subject { CachedThreadPool.new(max_threads: 5) }
 
-    it_should_behave_like 'Thread Pool'
+    after(:each) do
+      subject.kill
+      sleep(0.1)
+    end
+
+    it_should_behave_like :thread_pool
 
     context '#initialize' do
 
-      it 'aliases Concurrent#new_cached_thread_pool' do
-        pool = Concurrent.new_cached_thread_pool
-        pool.should be_a(CachedThreadPool)
-        pool.size.should eq 0
+      it 'raises an exception when the pool size is less than one' do
+        lambda {
+          CachedThreadPool.new(max: 0)
+        }.should raise_error(ArgumentError)
       end
-    end
 
-    context '#kill' do
-
-      it 'kills all threads' do
-        Thread.should_receive(:kill).at_least(5).times
-        pool = CachedThreadPool.new
-        5.times{ sleep(0.1); pool << proc{ sleep(1) } }
-        sleep(1)
-        pool.kill
-        sleep(0.1)
+      it 'raises an exception when the pool size is greater than MAX_POOL_SIZE' do
+        lambda {
+          CachedThreadPool.new(max: CachedThreadPool::MAX_POOL_SIZE + 1)
+        }.should raise_error(ArgumentError)
       end
     end
 
@@ -51,28 +50,36 @@ module Concurrent
 
       it 'creates new workers when there are none available' do
         subject.size.should eq 0
-        5.times{ sleep(0.1); subject << proc{ sleep(1000) } }
+        5.times{ sleep(0.1); subject << proc{ sleep } }
         sleep(1)
         subject.size.should eq 5
       end
 
       it 'uses existing idle threads' do
-        5.times{ sleep(0.05); subject << proc{ sleep(0.5) } }
+        5.times{ subject << proc{ sleep(0.1) } }
         sleep(1)
-        3.times{ sleep(0.1); subject << proc{ sleep(0.5) } }
         subject.size.should eq 5
+        3.times{ subject << proc{ sleep } }
+        sleep(0.1)
+        subject.size.should eq 5
+      end
+
+      it 'never creates more than :max_threads threads' do
+        pool = CachedThreadPool.new(max: 5)
+        100.times{ sleep(0.01); pool << proc{ sleep } }
+        sleep(0.1)
+        pool.length.should eq 5
+        pool.kill
+      end
+
+      it 'sets :max_threads to MAX_POOL_SIZE when not given' do
+        CachedThreadPool.new.max_threads.should eq CachedThreadPool::MAX_POOL_SIZE
       end
     end
 
     context 'garbage collection' do
 
-      subject{ CachedThreadPool.new(gc_interval: 1, thread_idleime: 1) }
-
-      it 'starts when the first thread is added to the pool' do
-        subject.should_receive(:collect_garbage)
-        subject << proc{ nil }
-        sleep(0.1)
-      end
+      subject{ CachedThreadPool.new(gc_interval: 1, idletime: 0.1) }
 
       it 'removes from pool any thread that has been idle too long' do
         subject << proc{ nil }
@@ -87,27 +94,6 @@ module Concurrent
         sleep(1.5)
         subject.size.should eq 0
       end
-
-      it 'resets the working count appropriately' do
-        subject << proc{ sleep(1000) }
-        sleep(0.1)
-        subject << proc{ raise StandardError }
-        sleep(0.1)
-        subject << proc{ nil }
-
-        sleep(0.1)
-        subject.working.should eq 2
-
-        sleep(1.5)
-        subject.working.should eq 1
-      end
-
-      it 'stops collection when the pool size becomes zero' do
-        3.times{ sleep(0.1); subject << proc{ sleep(0.5) } }
-        subject.instance_variable_get(:@collector).status.should eq 'sleep'
-        sleep(1.5)
-        subject.instance_variable_get(:@collector).status.should be_false
-      end
     end
 
     context '#status' do

data/spec/concurrent/channel_spec.rb

@@ -0,0 +1,446 @@
+require 'spec_helper'
+require_relative 'runnable_shared'
+
+module Concurrent
+
+  describe Channel do
+
+    subject { Channel.new }
+    let(:runnable) { Channel }
+
+    it_should_behave_like :runnable
+
+    after(:each) do
+      subject.stop
+      @thread.kill unless @thread.nil?
+      sleep(0.1)
+    end
+
+    context '#post' do
+
+      it 'returns false when not running' do
+        subject.post.should be_false
+      end
+
+      it 'pushes a message onto the queue' do
+        @expected = false
+        channel = Channel.new{|msg| @expected = msg }
+        @thread = Thread.new{ channel.run }
+        @thread.join(0.1)
+        channel.post(true)
+        @thread.join(0.1)
+        @expected.should be_true
+        channel.stop
+      end
+
+      it 'returns the current size of the queue' do
+        channel = Channel.new{|msg| sleep }
+        @thread = Thread.new{ channel.run }
+        @thread.join(0.1)
+        channel.post(true).should == 1
+        @thread.join(0.1)
+        channel.post(true).should == 1
+        @thread.join(0.1)
+        channel.post(true).should == 2
+        channel.stop
+      end
+
+      it 'is aliased a <<' do
+        @expected = false
+        channel = Channel.new{|msg| @expected = msg }
+        @thread = Thread.new{ channel.run }
+        @thread.join(0.1)
+        channel << true
+        @thread.join(0.1)
+        @expected.should be_true
+        channel.stop
+      end
+    end
+
+    context '#run' do
+
+      it 'empties the queue' do
+        @thread = Thread.new{ subject.run }
+        @thread.join(0.1)
+        q = subject.instance_variable_get(:@queue)
+        q.size.should == 0
+      end
+    end
+
+    context '#stop' do
+
+      it 'empties the queue' do
+        channel = Channel.new{|msg| sleep }
+        @thread = Thread.new{ channel.run }
+        10.times { channel.post(true) }
+        @thread.join(0.1)
+        channel.stop
+        @thread.join(0.1)
+        q = channel.instance_variable_get(:@queue)
+        if q.size >= 1
+          q.pop.should == :stop
+        else
+          q.size.should == 0
+        end
+      end
+
+      it 'pushes a :stop message onto the queue' do
+        @thread = Thread.new{ subject.run }
+        @thread.join(0.1)
+        q = subject.instance_variable_get(:@queue)
+        q.should_receive(:push).once.with(:stop)
+        subject.stop
+        @thread.join(0.1)
+      end
+    end
+
+    context 'message handling' do
+
+      it 'runs the constructor block once for every message' do
+        @expected = 0
+        channel = Channel.new{|msg| @expected += 1 }
+        @thread = Thread.new{ channel.run }
+        @thread.join(0.1)
+        10.times { channel.post(true) }
+        @thread.join(0.1)
+        @expected.should eq 10
+        channel.stop
+      end
+
+      it 'passes the message to the block' do
+        @expected = []
+        channel = Channel.new{|msg| @expected << msg }
+        @thread = Thread.new{ channel.run }
+        @thread.join(0.1)
+        10.times {|i| channel.post(i) }
+        @thread.join(0.1)
+        channel.stop
+        @expected.should eq (0..9).to_a
+      end
+    end
+
+    context 'exception handling' do
+
+      it 'supresses exceptions thrown when handling messages' do
+        channel = Channel.new{|msg| raise StandardError }
+        @thread = Thread.new{ channel.run }
+        expect {
+          @thread.join(0.1)
+          10.times { channel.post(true) }
+        }.not_to raise_error
+        channel.stop
+      end
+
+      it 'calls the errorback with the time, message, and exception' do
+        @expected = []
+        errorback = proc{|*args| @expected = args }
+        channel = Channel.new(errorback){|msg| raise StandardError }
+        @thread = Thread.new{ channel.run }
+        @thread.join(0.1)
+        channel.post(42)
+        @thread.join(0.1)
+        @expected[0].should be_a(Time)
+        @expected[1].should == [42]
+        @expected[2].should be_a(StandardError)
+        channel.stop
+      end
+    end
+
+    context 'observer notification' do
+
+      let(:observer) do
+        Class.new {
+          attr_reader :notice
+          def update(*args) @notice = args; end
+        }.new
+      end
+
+      it 'notifies observers when a message is successfully handled' do
+        observer.should_receive(:update).exactly(10).times.with(any_args())
+        subject.add_observer(observer)
+        @thread = Thread.new{ subject.run }
+        @thread.join(0.1)
+        10.times { subject.post(true) }
+        @thread.join(0.1)
+      end
+
+      it 'does not notify observers when a message raises an exception' do
+        observer.should_not_receive(:update).with(any_args())
+        channel = Channel.new{|msg| raise StandardError }
+        channel.add_observer(observer)
+        @thread = Thread.new{ channel.run }
+        @thread.join(0.1)
+        10.times { channel.post(true) }
+        @thread.join(0.1)
+        channel.stop
+      end
+
+      it 'passes the time, message, and result to the observer' do
+        channel = Channel.new{|*msg| msg }
+        channel.add_observer(observer)
+        @thread = Thread.new{ channel.run }
+        @thread.join(0.1)
+        channel.post(42)
+        @thread.join(0.1)
+        observer.notice[0].should be_a(Time)
+        observer.notice[1].should == [42]
+        observer.notice[2].should == [42]
+        channel.stop
+      end
+    end
+
+    context '#pool' do
+
+      let(:clazz){ Class.new(Channel) }
+
+      it 'raises an exception if the count is zero or less' do
+        expect {
+          clazz.pool(0)
+        }.to raise_error(ArgumentError)
+      end
+  
+      it 'creates the requested number of channels' do
+        mailbox, channels = clazz.pool(5)
+        channels.size.should == 5
+      end
+
+      it 'passes the errorback to each channel' do
+        errorback = proc{ nil }
+        clazz.should_receive(:new).with(errorback)
+        clazz.pool(1, errorback)
+      end
+
+      it 'passes the block to each channel' do
+        block = proc{ nil }
+        clazz.should_receive(:new).with(anything(), &block)
+        clazz.pool(1, nil, &block)
+      end
+
+      it 'gives all channels the same mailbox' do
+        mailbox, channels = clazz.pool(2)
+        mbox1 = channels.first.instance_variable_get(:@queue)
+        mbox2 = channels.last.instance_variable_get(:@queue)
+        mbox1.should eq mbox2
+      end
+
+      it 'returns a Poolbox as the first retval' do
+        mailbox, channels = clazz.pool(2)
+        mailbox.should be_a(Channel::Poolbox)
+      end
+
+      it 'gives the Poolbox the same mailbox as the channels' do
+        mailbox, channels = clazz.pool(1)
+        mbox1 = mailbox.instance_variable_get(:@queue)
+        mbox2 = channels.first.instance_variable_get(:@queue)
+        mbox1.should eq mbox2
+      end
+
+      it 'returns an array of channels as the second retval' do
+        mailbox, channels = clazz.pool(2)
+        channels.each do |channel|
+          channel.should be_a(clazz)
+        end
+      end
+
+      it 'posts to the mailbox with Poolbox#post' do
+        @expected = false
+        mailbox, channels = clazz.pool(1){|msg| @expected = true }
+        @thread = Thread.new{ channels.first.run }
+        sleep(0.1)
+        mailbox.post(42)
+        sleep(0.1)
+        channels.each{|channel| channel.stop }
+        @thread.kill
+        @expected.should be_true
+      end
+
+      it 'posts to the mailbox with Poolbox#<<' do
+        @expected = false
+        mailbox, channels = clazz.pool(1){|msg| @expected = true }
+        @thread = Thread.new{ channels.first.run }
+        sleep(0.1)
+        mailbox << 42
+        sleep(0.1)
+        channels.each{|channel| channel.stop }
+        @thread.kill
+        @expected.should be_true
+      end
+    end
+
+    context 'subclassing' do
+
+      after(:each) do
+        @thread.kill unless @thread.nil?
+      end
+
+      context '#pool' do
+
+        it 'creates channels of the appropriate subclass' do
+          actor = Class.new(Channel)
+          mailbox, channels = actor.pool(1)
+          channels.first.should be_a(actor)
+        end
+      end
+
+      context '#receive overloading' do
+
+        let(:actor) do
+          Class.new(Channel) {
+            attr_reader :last_message
+            def receive(*message)
+              @last_message = message
+            end
+          }
+        end
+
+        it 'ignores the constructor block' do
+          @expected = false
+          channel = actor.new{|*args| @expected = true }
+          @thread = Thread.new{ channel.run }
+          @thread.join(0.1)
+          channel.post(:foo)
+          @thread.join(0.1)
+          @expected.should be_false
+          channel.stop
+        end
+
+        it 'uses the subclass receive implementation' do
+          channel = actor.new{|*args| @expected = true }
+          @thread = Thread.new{ channel.run }
+          @thread.join(0.1)
+          channel.post(:foo)
+          @thread.join(0.1)
+          channel.last_message.should eq [:foo]
+          channel.stop
+        end
+      end
+
+      context '#receive pattern matching' do
+
+        let(:actor) do
+          Class.new(Channel) {
+            include PatternMatching
+            attr_reader :last_message
+            defn(:receive, :foo){|*args| @last_message = 'FOO' }
+            defn(:receive, :foo, :bar){|_, _| @last_message = 'FUBAR'}
+          }
+        end
+
+        it 'recognizes #defn pattern matches' do
+          channel = actor.new
+          @thread = Thread.new{ channel.run }
+          @thread.join(0.1)
+
+          channel.post(:foo)
+          @thread.join(0.1)
+          channel.last_message.should eq 'FOO'
+
+          channel.post(:foo, :bar)
+          @thread.join(0.1)
+          channel.last_message.should eq 'FUBAR'
+          
+          channel.stop
+        end
+
+        it 'falls back to the superclass #receive on no match' do
+          @expected = false
+          channel = actor.new{|*args| @expected = true }
+          @thread = Thread.new{ channel.run }
+          @thread.join(0.1)
+
+          channel.post(1, 2, 3, 4, 5)
+          @thread.join(0.1)
+          @expected.should be_true
+
+          channel.stop
+        end
+      end
+
+      context '#on_error overloading' do
+
+        let(:actor) do
+          Class.new(Channel) {
+            attr_reader :last_error
+            def receive(*message)
+              raise StandardError
+            end
+            def on_error(*args)
+              @last_error = args
+            end
+          }
+        end
+
+        it 'ignores the constructor errorback' do
+          @expected = false
+          errorback = proc{|*args| @expected = true }
+          channel = actor.new(errorback)
+          @thread = Thread.new{ channel.run }
+          @thread.join(0.1)
+          channel.post(true)
+          @thread.join(0.1)
+          @expected.should be_false
+          channel.stop
+        end
+
+        it 'uses the subclass #on_error implementation' do
+          channel = actor.new
+          @thread = Thread.new{ channel.run }
+          @thread.join(0.1)
+          channel.post(42)
+          @thread.join(0.1)
+          channel.last_error[0].should be_a(Time)
+          channel.last_error[1].should eq [42]
+          channel.last_error[2].should be_a(StandardError)
+          channel.stop
+        end
+      end
+    end
+
+    context 'supervision' do
+
+      it 'can be started by a Supervisor' do
+        channel = Channel.new
+        supervisor = Supervisor.new
+        supervisor.add_worker(channel)
+        
+        channel.should_receive(:run).with(no_args())
+        supervisor.run!
+        sleep(0.1)
+
+        supervisor.stop
+        sleep(0.1)
+        channel.stop
+      end
+
+      it 'can receive messages while under supervision' do
+        @expected = false
+        channel = Channel.new{|*args| @expected = true}
+        supervisor = Supervisor.new
+        supervisor.add_worker(channel)
+        supervisor.run!
+        sleep(0.1)
+
+        channel.post(42)
+        sleep(0.1)
+        @expected.should be_true
+
+        supervisor.stop
+        sleep(0.1)
+        channel.stop
+      end
+
+      it 'can be stopped by a supervisor' do
+        channel = Channel.new
+        supervisor = Supervisor.new
+        supervisor.add_worker(channel)
+        
+        supervisor.run!
+        sleep(0.1)
+
+        channel.should_receive(:stop).with(no_args())
+        supervisor.stop
+        sleep(0.1)
+      end
+    end
+  end
+end