concurrent-ruby 0.0.1 → 0.1.0

data/spec/concurrent/agent_spec.rb

@@ -0,0 +1,405 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe Agent do
+
+    subject { Agent.new(0) }
+
+    let(:observer) do
+      Class.new do
+        attr_reader :value
+        define_method(:update) do |time, value|
+          @value = value
+        end
+      end.new
+    end
+
+    before(:each) do
+      $GLOBAL_THREAD_POOL = CachedThreadPool.new
+    end
+
+    context '#initialize' do
+
+      it 'sets the value to the given initial state' do
+        Agent.new(10).value.should eq 10
+      end
+
+      it 'sets the timeout to the given value' do
+        Agent.new(0, 5).timeout.should eq 5
+      end
+
+      it 'sets the timeout to the default when nil' do
+        Agent.new(0).timeout.should eq Agent::TIMEOUT
+      end
+
+      it 'sets the length to zero' do
+        Agent.new(10).length.should eq 0
+      end
+
+      it 'spawns the worker thread' do
+        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
+        Agent.new(0)
+      end
+    end
+
+    context '#rescue' do
+
+      it 'returns self when a block is given' do
+        a1 = subject
+        a2 = a1.rescue{}
+        a1.object_id.should eq a2.object_id
+      end
+
+      it 'returns self when no block is given' do
+        a1 = subject
+        a2 = a1.rescue
+        a1.object_id.should eq a2.object_id
+      end
+
+      it 'accepts an exception class as the first parameter' do
+        lambda {
+          subject.rescue(StandardError){}
+        }.should_not raise_error
+      end
+
+      it 'ignores rescuers without a block' do
+        subject.rescue
+        subject.instance_variable_get(:@rescuers).should be_empty
+      end
+    end
+
+    context '#validate' do
+
+      it 'returns self when a block is given' do
+        a1 = subject
+        a2 = a1.validate{}
+        a1.object_id.should eq a2.object_id
+      end
+
+      it 'returns self when no block is given' do
+        a1 = subject
+        a2 = a1.validate
+        a1.object_id.should eq a2.object_id
+      end
+
+      it 'ignores validators without a block' do
+        subject.validate
+        subject.instance_variable_get(:@validator).should be_nil
+      end
+    end
+
+    context '#post' do
+      
+      it 'adds the given block to the queue' do
+        before = subject.length
+        subject.post{ nil }
+        subject.post{ nil }
+        subject.length.should eq before+2
+      end
+
+      it 'does not add to the queue when no block is given' do
+        before = subject.length
+        subject.post
+        subject.post{ nil }
+        subject.length.should eq before+1
+      end
+    end
+
+    context '#length' do
+
+      it 'should be zero for a new agent' do
+        subject.length.should eq 0
+      end
+
+      it 'should increase by one for each #post' do
+        subject.post{ sleep }
+        subject.post{ sleep }
+        subject.post{ sleep }
+        subject.length.should eq 3
+      end
+
+      it 'should decrease by one each time a handler is run' do
+        subject.post{ nil }
+        subject.post{ sleep }
+        subject.post{ sleep }
+        sleep(0.1)
+        subject.length.should eq 1
+      end
+    end
+
+    context 'fulfillment' do
+
+      it 'process each block in the queue' do
+        @expected = []
+        subject.post{ @expected << 1 }
+        subject.post{ @expected << 2 }
+        subject.post{ @expected << 3 }
+        sleep(0.1)
+        @expected.should eq [1,2,3]
+      end
+
+      it 'passes the current value to the handler' do
+        @expected = nil
+        Agent.new(10).post{|i| @expected = i }
+        sleep(0.1)
+        @expected.should eq 10
+      end
+
+      it 'sets the value to the handler return value on success' do
+        subject.post{ 100 }
+        sleep(0.1)
+        subject.value.should eq 100
+      end
+
+      it 'rejects the handler after timeout reached' do
+        agent = Agent.new(0, 0.1)
+        agent.post{ sleep(1); 10 }
+        agent.value.should eq 0
+      end
+    end
+
+    context 'validation' do
+
+      it 'processes the validator when present' do
+        @expected = nil
+        subject.validate{ @expected = 10; true }
+        subject.post{ nil }
+        sleep(0.1)
+        @expected.should eq 10
+      end
+
+      it 'passes the new value to the validator' do
+        @expected = nil
+        subject.validate{|v| @expected = v; true }
+        subject.post{ 10 }
+        sleep(0.1)
+        @expected.should eq 10
+      end
+
+      it 'sets the new value when the validator returns true' do
+        agent = Agent.new(0).validate{ true }
+        agent.post{ 10 }
+        sleep(0.1)
+        agent.value.should eq 10
+      end
+
+      it 'does not change the value when the validator returns false' do
+        agent = Agent.new(0).validate{ false }
+        agent.post{ 10 }
+        sleep(0.1)
+        agent.value.should eq 0
+      end
+
+      it 'does not change the value when the validator raises an exception' do
+        agent = Agent.new(0).validate{ raise StandardError }
+        agent.post{ 10 }
+        sleep(0.1)
+        agent.value.should eq 0
+      end
+    end
+
+    context 'rejection' do
+
+      it 'calls the first exception block with a matching class' do
+        @expected = nil
+        subject.
+          rescue(StandardError){|ex| @expected = 1 }.
+          rescue(StandardError){|ex| @expected = 2 }.
+          rescue(StandardError){|ex| @expected = 3 }
+        subject.post{ raise StandardError }
+          sleep(0.1)
+        @expected.should eq 1
+      end
+
+      it 'matches all with a rescue with no class given' do
+        @expected = nil
+        subject.
+          rescue(LoadError){|ex| @expected = 1 }.
+          rescue{|ex| @expected = 2 }.
+          rescue(StandardError){|ex| @expected = 3 }
+        subject.post{ raise NoMethodError }
+        sleep(0.1)
+        @expected.should eq 2
+      end
+
+      it 'searches associated rescue handlers in order' do
+        @expected = nil
+        subject.
+          rescue(ArgumentError){|ex| @expected = 1 }.
+          rescue(LoadError){|ex| @expected = 2 }.
+          rescue(Exception){|ex| @expected = 3 }
+        subject.post{ raise ArgumentError }
+        sleep(0.1)
+        @expected.should eq 1
+
+        @expected = nil
+        subject.
+          rescue(ArgumentError){|ex| @expected = 1 }.
+          rescue(LoadError){|ex| @expected = 2 }.
+          rescue(Exception){|ex| @expected = 3 }
+        subject.post{ raise LoadError }
+        sleep(0.1)
+        @expected.should eq 2
+
+        @expected = nil
+        subject.
+          rescue(ArgumentError){|ex| @expected = 1 }.
+          rescue(LoadError){|ex| @expected = 2 }.
+          rescue(Exception){|ex| @expected = 3 }
+        subject.post{ raise StandardError }
+        sleep(0.1)
+        @expected.should eq 3
+      end
+
+      it 'passes the exception object to the matched block' do
+        @expected = nil
+        subject.
+          rescue(ArgumentError){|ex| @expected = ex }.
+          rescue(LoadError){|ex| @expected = ex }.
+          rescue(Exception){|ex| @expected = ex }
+        subject.post{ raise StandardError }
+        sleep(0.1)
+        @expected.should be_a(StandardError)
+      end
+
+      it 'ignores rescuers without a block' do
+        @expected = nil
+        subject.
+          rescue(StandardError).
+          rescue(StandardError){|ex| @expected = ex }.
+          rescue(Exception){|ex| @expected = ex }
+        subject.post{ raise StandardError }
+        sleep(0.1)
+        @expected.should be_a(StandardError)
+      end
+
+      it 'supresses the exception if no rescue matches' do
+        lambda {
+          subject.
+            rescue(ArgumentError){|ex| @expected = ex }.
+            rescue(StandardError){|ex| @expected = ex }.
+            rescue(Exception){|ex| @expected = ex }
+          subject.post{ raise StandardError }
+          sleep(0.1)
+        }.should_not raise_error
+      end
+
+      it 'supresses exceptions thrown from rescue handlers' do
+        lambda {
+          subject.rescue(Exception){ raise StandardError }
+          subject.post{ raise ArgumentError }
+          sleep(0.1)
+        }.should_not raise_error
+      end
+    end
+
+    context 'observation' do
+
+      it 'notifies all observers when the value changes' do
+        agent = Agent.new(0)
+        agent.add_observer(observer)
+        agent.post{ 10 }
+        sleep(0.1)
+        observer.value.should eq 10
+      end
+
+      it 'does not notify observers when validation fails' do
+        agent = Agent.new(0)
+        agent.validate{ false }
+        agent.add_observer(observer)
+        agent.post{ 10 }
+        sleep(0.1)
+        observer.value.should be_nil
+      end
+
+      it 'does not notify observers when the handler raises an exception' do
+        agent = Agent.new(0)
+        agent.add_observer(observer)
+        agent.post{ raise StandardError }
+        sleep(0.1)
+        observer.value.should be_nil
+      end
+    end
+
+    context 'aliases' do
+
+      it 'aliases #deref for #value' do
+        Agent.new(10).deref.should eq 10
+      end
+
+      it 'aliases #validates for :validate' do
+        @expected = nil
+        subject.validates{|v| @expected = v }
+        subject.post{ 10 }
+        sleep(0.1)
+        @expected.should eq 10
+      end
+        
+      it 'aliases #validate_with for :validate' do
+        @expected = nil
+        subject.validate_with{|v| @expected = v }
+        subject.post{ 10 }
+        sleep(0.1)
+        @expected.should eq 10
+      end
+
+      it 'aliases #validates_with for :validate' do
+        @expected = nil
+        subject.validates_with{|v| @expected = v }
+        subject.post{ 10 }
+        sleep(0.1)
+        @expected.should eq 10
+      end
+
+      it 'aliases #catch for #rescue' do
+        @expected = nil
+        subject.catch{ @expected = true }
+        subject.post{ raise StandardError }
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'aliases #on_error for #rescue' do
+        @expected = nil
+        subject.on_error{ @expected = true }
+        subject.post{ raise StandardError }
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'aliases #add_watch for #add_observer' do
+        agent = Agent.new(0)
+        agent.add_watch(observer)
+        agent.post{ 10 }
+        sleep(0.1)
+        observer.value.should eq 10
+      end
+
+      it 'aliases #<< for Agent#post' do
+        subject << proc{ 100 }
+        sleep(0.1)
+        subject.value.should eq 100
+
+        subject << lambda{ 100 }
+        sleep(0.1)
+        subject.value.should eq 100
+      end
+
+      it 'aliases Kernel#agent for Agent.new' do
+        agent(10).should be_a(Agent)
+      end
+
+      it 'aliases Kernel#deref for #deref' do
+        deref(Agent.new(10)).should eq 10
+        deref(Agent.new(10), 10).should eq 10
+      end
+
+      it 'aliases Kernel:post for Agent#post' do
+        post(subject){ 100 }
+        sleep(0.1)
+        subject.value.should eq 100
+      end
+    end
+  end
+end

data/spec/concurrent/cached_thread_pool_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require_relative 'thread_pool_shared'
+
+module Concurrent
+
+  describe CachedThreadPool do
+
+    subject { CachedThreadPool.new }
+
+    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
+      end
+    end
+
+    context '#kill' do
+
+      it 'kills all threads' do
+        Thread.should_receive(:kill).exactly(5).times
+        pool = CachedThreadPool.new
+        5.times{ sleep(0.1); pool << proc{ sleep(1) } }
+        sleep(1)
+        pool.kill
+        sleep(0.1)
+      end
+    end
+
+    context '#size' do
+
+      it 'returns zero for a new thread pool' do
+        subject.size.should eq 0
+      end
+
+      it 'returns the size of the subject when running' do
+        5.times{ sleep(0.1); subject << proc{ sleep(1) } }
+        subject.size.should eq 5
+      end
+
+      it 'returns zero once shut down' do
+        subject.shutdown
+        subject.size.should eq 0
+      end
+    end
+
+    context 'worker creation and caching' do
+
+      it 'creates new workers when there are none available' do
+        subject.size.should eq 0
+        5.times{ sleep(0.1); subject << proc{ sleep(1000) } }
+        sleep(1)
+        subject.size.should eq 5
+      end
+
+      it 'uses existing idle threads' do
+        5.times{ sleep(0.05); subject << proc{ sleep(0.5) } }
+        sleep(1)
+        3.times{ sleep(0.1); subject << proc{ sleep(0.5) } }
+        subject.size.should eq 5
+      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
+
+      it 'removes from pool any thread that has been idle too long' do
+        subject << proc{ nil }
+        subject.size.should eq 1
+        sleep(1.5)
+        subject.size.should eq 0
+      end
+
+      it 'removed from pool any dead thread' do
+        subject << proc{ raise StandardError }
+        subject.size.should eq 1
+        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
+  end
+end