functional-ruby 0.5.0 → 0.6.0

data/spec/functional/behavior_spec.rb

@@ -1,37 +1,16 @@
 require 'spec_helper'
 
-#behaviour_info(:gen_foo, foo: 0, bar: 1, baz: 2, boom: -1, bam: :any)
-
-#class Foo
-  #behavior(:gen_foo)
-
-  #def foo
-    #return 'foo/0'
-  #end
-
-  #def bar(one, &block)
-    #return 'bar/1'
-  #end
-
-  #def baz(one, two)
-    #return 'baz/2'
-  #end
-
-  #def boom(*args)
-    #return 'boom/-1'
-  #end
-
-  #def bam
-    #return 'bam!'
-  #end
-#end
-
-describe 'behavior/interface definitions' do
+describe '-behavior' do
 
   before(:each) do
+    @__behavior_info__ = $__behavior_info__
     $__behavior_info__ = {}
   end
 
+  after(:each) do
+    $__behavior_info__ = @__behavior_info__
+  end
+
   context 'behavior_info/2' do
 
     it 'accepts a symbol name' do
@@ -77,7 +56,7 @@ describe 'behavior/interface definitions' do
         Class.new{
           behavior(:gen_foo)
         }
-      }.should raise_error(ArgumentError)
+      }.should raise_error(BehaviorError)
     end
 
     it 'can be called multiple times for one class' do
@@ -93,7 +72,7 @@ describe 'behavior/interface definitions' do
     end
   end
 
-  context 'behavior check on object creation' do
+  context 'object creation' do
 
     it 'raises an exception when one or more function definitions are missing' do
       behavior_info(:gen_foo, foo: 0, bar: 1)
@@ -104,7 +83,7 @@ describe 'behavior/interface definitions' do
 
       lambda {
         clazz.new
-      }.should raise_error(ArgumentError)
+      }.should raise_error(BehaviorError)
     end
 
     it 'raises an exception when one or more functions do not have proper arity' do
@@ -116,7 +95,7 @@ describe 'behavior/interface definitions' do
 
       lambda {
         clazz.new
-      }.should raise_error(ArgumentError)
+      }.should raise_error(BehaviorError)
     end
 
     it 'accepts any arity when function arity is set to :any' do
@@ -128,7 +107,7 @@ describe 'behavior/interface definitions' do
 
       lambda {
         clazz.new
-      }.should_not raise_error(ArgumentError)
+      }.should_not raise_error(BehaviorError)
     end
 
     it 'creates the object when function definitions match' do
@@ -141,7 +120,7 @@ describe 'behavior/interface definitions' do
 
       lambda {
         clazz.new
-      }.should_not raise_error(ArgumentError)
+      }.should_not raise_error(BehaviorError)
     end
   end
 

data/spec/functional/cached_thread_pool_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require_relative 'thread_pool_shared'
+
+module Functional
+
+  describe CachedThreadPool do
+
+    subject { CachedThreadPool.new }
+
+    it_should_behave_like 'Thread Pool'
+
+    context '#initialize' do
+      it 'aliases Functional#new_cached_thread_pool' do
+        pool = Functional.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

data/spec/functional/concurrency_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Functional
+
+  describe 'concurrency' do
+
+    context '#go' do
+
+      before(:each) do
+        $GLOBAL_THREAD_POOL = CachedThreadPool.new
+      end
+
+      it 'passes all arguments to the block' do
+        @expected = nil
+        go(1, 2, 3){|a, b, c| @expected = [c, b, a] }
+        sleep(0.1)
+        @expected.should eq [3, 2, 1]
+      end
+
+      it 'returns true if the thread is successfully created' do
+        $GLOBAL_THREAD_POOL.should_receive(:post).and_return(true)
+        go{ nil }.should be_true
+      end
+
+      it 'returns false if the thread cannot be created' do
+        $GLOBAL_THREAD_POOL.should_receive(:post).and_return(false)
+        go{ nil }.should be_false
+      end
+
+      it 'immediately returns false if no block is given' do
+        go().should be_false
+      end
+
+      it 'does not create a thread if no block is given' do
+        $GLOBAL_THREAD_POOL.should_not_receive(:post)
+        go()
+        sleep(0.1)
+      end
+
+      it 'supresses exceptions on the thread' do
+        lambda{
+          go{ raise StandardError }
+          sleep(0.1)
+        }.should_not raise_error
+      end
+
+      it 'processes the block' do
+        @expected = false
+        go(1,2,3){|*args| @expected = args }
+        sleep(0.1)
+        @expected.should eq [1,2,3]
+      end
+    end
+  end
+end

data/spec/functional/event_machine_defer_proxy_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+require 'functional/agent'
+require 'functional/future'
+require 'functional/promise'
+
+module Functional
+
+  describe EventMachineDeferProxy do
+
+    subject { EventMachineDeferProxy.new }
+
+    context '#post' do
+
+      it 'proxies a call without arguments' do
+        @expected = false
+        EventMachine.run do
+          subject.post{ @expected = true }
+          sleep(0.1)
+          EventMachine.stop
+        end
+        @expected.should eq true
+      end
+
+      it 'proxies a call with arguments' do
+        @expected = []
+        EventMachine.run do
+          subject.post(1,2,3){|*args| @expected = args }
+          sleep(0.1)
+          EventMachine.stop
+        end
+        @expected.should eq [1,2,3]
+      end
+
+      it 'aliases #<<' do
+        @expected = false
+        EventMachine.run do
+          subject << proc{ @expected = true }
+          sleep(0.1)
+          EventMachine.stop
+        end
+        @expected.should eq true
+      end
+    end
+
+    context 'operation' do
+
+      context 'goroutine' do
+
+        it 'passes all arguments to the block' do
+          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+          EventMachine.run do
+
+            @expected = nil
+            go(1, 2, 3){|a, b, c| @expected = [c, b, a] }
+            sleep(0.1)
+            @expected.should eq [3, 2, 1]
+
+            EventMachine.stop
+          end
+        end
+      end
+
+      context Agent do
+
+        subject { Agent.new(0) }
+
+        it 'supports fulfillment' do
+          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+          EventMachine.run do
+
+            @expected = []
+            subject.post{ @expected << 1 }
+            subject.post{ @expected << 2 }
+            subject.post{ @expected << 3 }
+            sleep(0.1)
+            @expected.should eq [1,2,3]
+
+            EventMachine.stop
+          end
+        end
+
+        it 'supports validation' do
+          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+          EventMachine.run do
+
+            @expected = nil
+            subject.validate{ @expected = 10; true }
+            subject.post{ nil }
+            sleep(0.1)
+            @expected.should eq 10
+
+            EventMachine.stop
+          end
+        end
+
+        it 'supports rejection' do
+          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+          EventMachine.run do
+
+            @expected = nil
+            subject.
+              on_error(StandardError){|ex| @expected = 1 }.
+              on_error(StandardError){|ex| @expected = 2 }.
+              on_error(StandardError){|ex| @expected = 3 }
+            subject.post{ raise StandardError }
+            sleep(0.1)
+            @expected.should eq 1
+
+            EventMachine.stop
+          end
+        end
+      end
+
+      context Future do
+
+        it 'supports fulfillment' do
+          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+          EventMachine.run do
+
+            @a = @b = @c = nil
+            f = Future.new(1, 2, 3) do |a, b, c|
+              @a, @b, @c = a, b, c
+            end
+            sleep(0.1)
+            [@a, @b, @c].should eq [1, 2, 3]
+
+            sleep(0.1)
+            EventMachine.stop
+          end
+        end
+      end
+
+      context Promise do
+
+        context 'fulfillment' do
+
+          it 'passes all arguments to the first promise in the chain' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+
+              @a = @b = @c = nil
+              p = Promise.new(1, 2, 3) do |a, b, c|
+                @a, @b, @c = a, b, c
+              end
+              sleep(0.1)
+              [@a, @b, @c].should eq [1, 2, 3]
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+
+          it 'passes the result of each block to all its children' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+              @expected = nil
+              Promise.new(10){|a| a * 2 }.then{|result| @expected = result}
+              sleep(0.1)
+              @expected.should eq 20
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+
+          it 'sets the promise value to the result if its block' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+
+              p = Promise.new(10){|a| a * 2 }.then{|result| result * 2}
+              sleep(0.1)
+              p.value.should eq 40
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+        end
+
+        context 'rejection' do
+
+          it 'sets the promise reason and error on exception' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+
+              p = Promise.new{ raise StandardError.new('Boom!') }
+              sleep(0.1)
+              p.reason.should be_a(Exception)
+              p.reason.should.to_s =~ /Boom!/
+              p.should be_rejected
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+
+          it 'calls the first exception block with a matching class' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+
+              @expected = nil
+              Promise.new{ raise StandardError }.
+                on_error(StandardError){|ex| @expected = 1 }.
+                on_error(StandardError){|ex| @expected = 2 }.
+                on_error(StandardError){|ex| @expected = 3 }
+              sleep(0.1)
+              @expected.should eq 1
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+
+          it 'passes the exception object to the matched block' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+
+              @expected = nil
+              Promise.new{ raise StandardError }.
+                on_error(ArgumentError){|ex| @expected = ex }.
+                on_error(LoadError){|ex| @expected = ex }.
+                on_error(Exception){|ex| @expected = ex }
+              sleep(0.1)
+              @expected.should be_a(StandardError)
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/functional/event_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+module Functional
+
+  describe Event do
+
+    subject{ Event.new }
+
+    context '#initialize' do
+
+      it 'sets the state to unset' do
+        subject.should_not be_set
+      end
+    end
+
+    context '#set?' do
+
+      it 'returns true when the event has been set' do
+        subject.set
+        subject.should be_set
+      end
+
+      it 'returns false if the event is unset' do
+        subject.reset
+        subject.should_not be_set
+      end
+    end
+
+    context '#set' do
+
+      it 'triggers the event' do
+        subject.reset
+        @expected = false
+        Thread.new{ sleep(0.5); subject.wait; @expected = true }
+        subject.set
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'sets the state to set' do
+        subject.set
+        subject.should be_set
+      end
+    end
+
+    context '#reset' do
+
+      it 'sets the state to unset' do
+        subject.set
+        subject.should be_set
+        subject.reset
+        subject.should_not be_set
+      end
+    end
+
+    context '#wait' do
+
+      it 'returns immediately when the event has been set' do
+        subject.reset
+        @expected = false
+        subject.set
+        Thread.new{ subject.wait(1000); @expected = true}
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'returns true once the event is set' do
+        subject.set
+        subject.wait.should be_true
+      end
+
+      it 'blocks indefinitely when the timer is nil' do
+        subject.reset
+        @expected = false
+        Thread.new{ subject.wait; @expected = true}
+        subject.set
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'stops waiting when the timer expires' do
+        subject.reset
+        @expected = false
+        Thread.new{ subject.wait(0.5); @expected = true}
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'returns false when the timer expires' do
+        subject.reset
+        subject.wait(1).should be_false
+      end
+
+      it 'triggers multiple waiting threads' do
+        subject.reset
+        @expected = []
+        5.times{ Thread.new{ subject.wait; @expected << Thread.current.object_id } }
+        subject.set
+        sleep(1)
+        @expected.length.should eq 5
+      end
+
+      it 'behaves appropriately if wait begins while #set is processing' do
+        subject.reset
+        @expected = []
+        5.times{ Thread.new{ subject.wait(5) } }
+        subject.set
+        5.times{ Thread.new{ subject.wait; @expected << Thread.current.object_id } }
+        sleep(1)
+        @expected.length.should eq 5
+      end
+    end
+  end
+end

data/spec/functional/fixed_thread_pool_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require_relative 'thread_pool_shared'
+
+module Functional
+
+  describe FixedThreadPool do
+
+    subject { FixedThreadPool.new(5) }
+
+    it_should_behave_like 'Thread Pool'
+
+    context '#initialize' do
+
+      it 'raises an exception when the pool size is less than one' do
+        lambda {
+          FixedThreadPool.new(0)
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'raises an exception when the pool size is greater than 1024' do
+        lambda {
+          FixedThreadPool.new(1025)
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'creates a thread pool of the given size' do
+        thread = mock('thread')
+        # add one for the garbage collector
+        Thread.should_receive(:new).exactly(5+1).times.and_return(thread)
+        pool = FixedThreadPool.new(5)
+        pool.size.should eq 5
+      end
+
+      it 'aliases Functional#new_fixed_thread_pool' do
+        pool = Functional.new_fixed_thread_pool(5)
+        pool.should be_a(FixedThreadPool)
+        pool.size.should eq 5
+      end
+    end
+
+    context '#kill' do
+
+      it 'kills all threads' do
+        Thread.should_receive(:kill).exactly(5).times
+        pool = FixedThreadPool.new(5)
+        pool.kill
+        sleep(0.1)
+      end
+    end
+
+    context '#size' do
+
+      let(:pool_size) { 3 }
+      subject { FixedThreadPool.new(pool_size) }
+
+      it 'returns the size of the subject when running' do
+        subject.size.should eq pool_size
+      end
+
+      it 'returns zero while shutting down' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.size.should eq 0
+      end
+
+      it 'returns zero once shut down' do
+        subject.shutdown
+        subject.size.should eq 0
+      end
+    end
+
+    context 'exception handling' do
+
+      it 'restarts threads that experience exception' do
+        pool = FixedThreadPool.new(5)
+        3.times{ pool << proc{ raise StandardError } }
+        sleep(2)
+        pool.size.should eq 5
+        pool.status.should_not include(nil)
+        #pool.status.include?(nil).should be_false
+      end
+    end
+  end
+end