functional-ruby 0.6.0 → 0.7.0

data/spec/functional/cached_thread_pool_spec.rb

@@ -1,112 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,246 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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