concurrent-ruby 0.6.0 → 0.7.0.rc0

data/spec/concurrent/promise_spec.rb

@@ -1,367 +0,0 @@
-require 'spec_helper'
-require_relative 'obligation_shared'
-
-module Concurrent
-
-  describe Promise do
-
-    let(:executor) { PerThreadExecutor.new }
-
-    let(:empty_root) { Promise.new(executor: executor){ nil } }
-    let!(:fulfilled_value) { 10 }
-    let!(:rejected_reason) { StandardError.new('mojo jojo') }
-
-    let(:pending_subject) do
-      Promise.new(executor: executor){ sleep(0.3); fulfilled_value }.execute
-    end
-
-    let(:fulfilled_subject) do
-      Promise.fulfill(fulfilled_value, executor: executor)
-    end
-
-    let(:rejected_subject) do
-      Promise.reject(rejected_reason, executor: executor)
-    end
-
-    it_should_behave_like :obligation
-
-    it 'includes Dereferenceable' do
-      promise = Promise.new{ nil }
-      promise.should be_a(Dereferenceable)
-    end
-
-    context 'initializers' do
-      describe '.fulfill' do
-
-        subject { Promise.fulfill(10) }
-
-        it 'should return a Promise' do
-          subject.should be_a Promise
-        end
-
-        it 'should return a fulfilled Promise' do
-          subject.should be_fulfilled
-        end
-
-        it 'should return a Promise with set value' do
-          subject.value.should eq 10
-        end
-      end
-
-      describe '.reject' do
-
-        let(:reason) { ArgumentError.new }
-        subject { Promise.reject(reason) }
-
-        it 'should return a Promise' do
-          subject.should be_a Promise
-        end
-
-        it 'should return a rejected Promise' do
-          subject.should be_rejected
-        end
-
-        it 'should return a Promise with set reason' do
-          subject.reason.should be reason
-        end
-      end
-
-      describe '.new' do
-        it 'should return an unscheduled Promise' do
-          p = Promise.new(executor: executor){ nil }
-          p.should be_unscheduled
-        end
-      end
-
-      describe '.execute' do
-        it 'creates a new Promise' do
-          p = Promise.execute(executor: executor){ nil }
-          p.should be_a(Promise)
-        end
-
-        it 'passes the block to the new Promise' do
-          p = Promise.execute(executor: executor){ 20 }
-          sleep(0.1)
-          p.value.should eq 20
-        end
-
-        it 'calls #execute on the new Promise' do
-          p = double('promise')
-          Promise.stub(:new).with({executor: executor}).and_return(p)
-          p.should_receive(:execute).with(no_args)
-          Promise.execute(executor: executor){ nil }
-        end
-      end
-    end
-
-    context '#execute' do
-
-      context 'unscheduled' do
-
-        it 'sets the promise to :pending' do
-          p = Promise.new(executor: executor){ sleep(0.1) }.execute
-          p.should be_pending
-        end
-
-        it 'posts the block given in construction' do
-          executor.should_receive(:post).with(any_args)
-          Promise.new(executor: executor){ nil }.execute
-        end
-      end
-
-      context 'pending' do
-
-        it 'sets the promise to :pending' do
-          p = pending_subject.execute
-          p.should be_pending
-        end
-
-        it 'does not posts again' do
-          executor.should_receive(:post).with(any_args).once
-          pending_subject.execute
-        end
-      end
-
-      describe 'with children' do
-
-        let(:root) { Promise.new(executor: executor){ sleep(0.1); nil } }
-        let(:c1) { root.then { sleep(0.1); nil } }
-        let(:c2) { root.then { sleep(0.1); nil } }
-        let(:c2_1) { c2.then { sleep(0.1); nil } }
-
-        context 'when called on the root' do
-          it 'should set all promises to :pending' do
-            root.execute
-
-            c1.should be_pending
-            c2.should be_pending
-            c2_1.should be_pending
-            [root, c1, c2, c2_1].each { |p| p.should be_pending }
-          end
-        end
-
-        context 'when called on a child' do
-          it 'should set all promises to :pending' do
-            c2_1.execute
-
-            [root, c1, c2, c2_1].each { |p| p.should be_pending }
-          end
-        end
-      end
-    end
-
-    describe '#then' do
-
-      it 'returns a new promise when a block is passed' do
-        child = empty_root.then { nil }
-        child.should be_a Promise
-        child.should_not be empty_root
-      end
-
-      it 'returns a new promise when a rescuer is passed' do
-        child = empty_root.then(Proc.new{})
-        child.should be_a Promise
-        child.should_not be empty_root
-      end
-
-      it 'returns a new promise when a block and rescuer are passed' do
-        child = empty_root.then(Proc.new{}) { nil }
-        child.should be_a Promise
-        child.should_not be empty_root
-      end
-
-      it 'should have block or rescuers' do
-        expect { empty_root.then }.to raise_error(ArgumentError)
-      end
-
-      context 'unscheduled' do
-
-        let(:p1) { Promise.new(executor: executor){nil} }
-        let(:child) { p1.then{} }
-
-        it 'returns a new promise' do
-          child.should be_a Promise
-          p1.should_not be child
-        end
-
-        it 'returns an unscheduled promise' do
-          child.should be_unscheduled
-        end
-      end
-
-      context 'pending' do
-
-        let(:child) { pending_subject.then{} }
-
-        it 'returns a new promise' do
-          child.should be_a Promise
-          pending_subject.should_not be child
-        end
-
-        it 'returns a pending promise' do
-          child.should be_pending
-        end
-      end
-
-      context 'fulfilled' do
-        it 'returns a new Promise' do
-          p1 = fulfilled_subject
-          p2 = p1.then{}
-          p2.should be_a(Promise)
-          p1.should_not eq p2
-        end
-
-        it 'notifies fulfillment to new child' do
-          child = fulfilled_subject.then(Proc.new{ 7 }) { |v| v + 5 }
-          child.value.should eq fulfilled_value + 5
-        end
-      end
-
-      context 'rejected' do
-        it 'returns a new Promise when :rejected' do
-          p1 = rejected_subject
-          p2 = p1.then{}
-          p2.should be_a(Promise)
-          p1.should_not eq p2
-        end
-
-        it 'notifies rejection to new child' do
-          child = rejected_subject.then(Proc.new{ 7 }) { |v| v + 5 }
-          child.value.should eq 7
-        end
-      end
-
-      it 'can be called more than once' do
-        p = pending_subject
-        p1 = p.then{}
-        p2 = p.then{}
-        p1.should_not be p2
-      end
-    end
-
-    describe 'on_success' do
-      it 'should have a block' do
-        expect { empty_root.on_success }.to raise_error(ArgumentError)
-      end
-
-      it 'returns a new promise' do
-        child = empty_root.on_success { nil }
-        child.should be_a Promise
-        child.should_not be empty_root
-      end
-    end
-
-    context '#rescue' do
-
-      it 'returns a new promise' do
-        child = empty_root.rescue { nil }
-        child.should be_a Promise
-        child.should_not be empty_root
-      end
-    end
-
-    context 'fulfillment' do
-
-      it 'passes the result of each block to all its children' do
-        expected = nil
-        Promise.new(executor: executor){ 20 }.then{ |result| expected = result }.execute
-        sleep(0.1)
-        expected.should eq 20
-      end
-
-      it 'sets the promise value to the result if its block' do
-        root = Promise.new(executor: executor){ 20 }
-        p = root.then{ |result| result * 2}.execute
-        sleep(0.1)
-        root.value.should eq 20
-        p.value.should eq 40
-      end
-
-      it 'sets the promise state to :fulfilled if the block completes' do
-        p = Promise.new(executor: executor){ 10 * 2 }.then{|result| result * 2}.execute
-        sleep(0.1)
-        p.should be_fulfilled
-      end
-
-      it 'passes the last result through when a promise has no block' do
-        expected = nil
-        Promise.new(executor: executor){ 20 }.then(Proc.new{}).then{|result| expected = result}.execute
-        sleep(0.1)
-        expected.should eq 20
-      end
-
-      it 'uses result as fulfillment value when a promise has no block' do
-        p = Promise.new(executor: executor){ 20 }.then(Proc.new{}).execute
-        sleep(0.1)
-        p.value.should eq 20
-      end
-
-      it 'can manage long chain' do
-        root = Promise.new(executor: executor){ 20 }
-        p1 = root.then { |b| b * 3 }
-        p2 = root.then { |c| c + 2 }
-        p3 = p1.then { |d| d + 7 }
-
-        root.execute
-        sleep(0.1)
-
-        root.value.should eq 20
-        p1.value.should eq 60
-        p2.value.should eq 22
-        p3.value.should eq 67
-      end
-    end
-
-    context 'rejection' do
-
-      it 'passes the reason to all its children' do
-        expected = nil
-        Promise.new(executor: executor){ raise ArgumentError }.then(Proc.new{ |reason| expected = reason }).execute
-        sleep(0.1)
-        expected.should be_a ArgumentError
-      end
-
-      it 'sets the promise value to the result if its block' do
-        root = Promise.new(executor: executor){ raise ArgumentError }
-        p = root.then(Proc.new{ |reason| 42 }).execute
-        sleep(0.1)
-        p.value.should eq 42
-      end
-
-      it 'sets the promise state to :rejected if the block completes' do
-        p = Promise.new(executor: executor){ raise ArgumentError }.execute
-        sleep(0.1)
-        p.should be_rejected
-      end
-
-      it 'uses reason as rejection reason when a promise has no rescue callable' do
-        p = Promise.new(executor: ImmediateExecutor.new){ raise ArgumentError }.then{ |val| val }.execute
-        sleep(0.1)
-        p.should be_rejected
-        p.reason.should be_a ArgumentError
-      end
-
-    end
-
-    context 'aliases' do
-
-      it 'aliases #realized? for #fulfilled?' do
-        fulfilled_subject.should be_realized
-      end
-
-      it 'aliases #deref for #value' do
-        fulfilled_subject.deref.should eq fulfilled_value
-      end
-
-      it 'aliases #catch for #rescue' do
-        child = rejected_subject.catch { 7 }
-        child.value.should eq 7
-      end
-
-      it 'aliases #on_error for #rescue' do
-        child = rejected_subject.on_error { 7 }
-        child.value.should eq 7
-      end
-    end
-  end
-end

data/spec/concurrent/runnable_shared.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-share_examples_for :runnable do
-
-  after(:each) do
-    subject.stop
-    @thread.kill unless @thread.nil?
-    sleep(0.1)
-  end
-
-  context '#run' do
-
-    it 'starts the (blocking) runner on the current thread when stopped' do
-      @thread = Thread.new { subject.run }
-      @thread.join(0.1).should be_nil
-    end
-
-    it 'raises an exception when already running' do
-      @thread = Thread.new { subject.run }
-      @thread.join(0.1)
-      expect {
-        subject.run
-      }.to raise_error
-    end
-
-    it 'returns true when stopped normally' do
-      @expected = false
-      @thread = Thread.new { @expected = subject.run }
-      @thread.join(0.1)
-      subject.stop
-      @thread.join(1)
-      @expected.should be_true
-    end
-  end
-
-  context '#stop' do
-
-    it 'returns true when not running' do
-      subject.stop.should be_true
-    end
-
-    it 'returns true when successfully stopped' do
-      @thread = Thread.new { subject.run }
-      @thread.join(0.1)
-      subject.stop.should be_true
-      subject.should_not be_running
-    end
-  end
-
-  context '#running?' do
-
-    it 'returns true when running' do
-      @thread = Thread.new { subject.run }
-      @thread.join(0.1)
-      subject.should be_running
-    end
-
-    it 'returns false when first created' do
-      subject.should_not be_running
-    end
-
-    it 'returns false when not running' do
-      subject.stop
-      sleep(0.1)
-      subject.should_not be_running
-    end
-  end
-end

data/spec/concurrent/runnable_spec.rb

@@ -1,235 +0,0 @@
-require 'spec_helper'
-require_relative 'runnable_shared'
-
-module Concurrent
-
-  describe Runnable do
-
-    let(:runnable) do
-      Class.new {
-        include Runnable
-        attr_reader :thread
-        def initialize(*args, &block)
-          yield if block_given?
-        end
-        def on_task
-          @thread = Thread.current
-          sleep(0.1)
-        end
-        def on_run() return true; end
-        def after_run() return true; end
-        def on_stop() return true; end
-      }
-    end
-
-    subject { runnable.new }
-
-    it_should_behave_like :runnable
-
-    after(:each) do
-      subject.stop
-      @thread.kill unless @thread.nil?
-      sleep(0.1)
-    end
-
-    context '#run' do
-
-      it 'calls #on_run when implemented' do
-        subject.should_receive(:on_run).with(no_args())
-        @thread = Thread.new { subject.run }
-        sleep(0.1)
-      end
-
-      it 'does not attempt to call #on_run when not implemented' do
-        subject.class.send(:remove_method, :on_run)
-        @thread = Thread.new do
-          expect {
-            subject.run
-          }.not_to raise_error
-        end
-        sleep(0.1)
-      end
-
-      it 'return false when #on_run raises an exception' do
-        @expected = true
-        subject.stub(:on_run).and_raise(StandardError)
-        @thread = Thread.new do
-          @expected = subject.run
-        end
-        sleep(0.1)
-        @expected.should be_false
-      end
-
-      it 'calls #on_task in an infinite loop' do
-        subject.should_receive(:on_task).with(no_args()).at_least(1)
-        @thread = Thread.new { subject.run }
-        @thread.join(1)
-      end
-
-      it 'raises an exception if the #on_task callback is not implemented' do
-        runner = Class.new { include Runnable }.new
-        expect {
-          runner.run
-        }.to raise_error(Concurrent::LifecycleError)
-      end
-
-      it 'returns false when the task loop raises an exception' do
-        @expected = false
-        subject.stub(:on_task).and_raise(StandardError)
-        @thread = Thread.new { @expected = subject.run }
-        @thread.join(0.1)
-        @expected.should be_false
-      end
-    end
-
-    context '#stop' do
-
-      it 'calls #on_stop when implemented' do
-        subject.should_receive(:on_stop).with(no_args())
-        @thread = Thread.new { subject.run }
-        sleep(0.1)
-        subject.stop
-        sleep(0.1)
-      end
-
-      it 'does not attempt to call #on_stop when not implemented' do
-        subject.class.send(:remove_method, :on_stop)
-        @thread = Thread.new { subject.run }
-        sleep(0.1)
-        expect {
-          subject.stop
-          sleep(0.1)
-        }.not_to raise_error
-      end
-
-      it 'return false when #on_stop raises an exception' do
-        subject.stub(:on_stop).and_raise(StandardError)
-        @thread = Thread.new { subject.run }
-        sleep(0.1)
-        subject.stop.should be_false
-        subject.should_not be_running
-      end
-
-      it 'calls #after_run when implemented' do
-        subject.should_receive(:after_run).with(no_args())
-        @thread = Thread.new { subject.run }
-        sleep(0.1)
-        subject.stop
-        sleep(0.2)
-      end
-
-      it 'does not attempt to call #after_run when not implemented' do
-        subject.class.send(:remove_method, :after_run)
-        @thread = Thread.new { subject.run }
-        sleep(0.1)
-        expect {
-          subject.stop
-          sleep(0.2)
-        }.not_to raise_error
-      end
-    end
-
-    context '#running?' do
-
-      it 'returns false if runner abends' do
-        subject.stub(:on_task).and_raise(StandardError)
-        @thread = Thread.new { subject.run }
-        @thread.join(0.1)
-        subject.should_not be_running
-      end
-    end
-
-    context 'instance #run!' do
-
-      after(:each) do
-        @thread.kill if @thread
-      end
-
-      it 'raises an exception when already running' do
-        @thread = Thread.new{ subject.run }
-        @thread.join(0.1)
-        expect {
-          @thread = subject.run!
-        }.to raise_exception(Concurrent::LifecycleError)
-        sleep(0.1)
-      end
-
-      it 'creates a new thread' do
-        t = Thread.new{ nil }
-        Thread.should_receive(:new).with(no_args()).and_return(t)
-        @thread = subject.run!
-      end
-
-      it 'calls the #run method on the new thread' do
-        subject.should_receive(:run)
-        @thread = subject.run!
-        sleep(0.1)
-      end
-
-      it 'returns the new thread' do
-        @thread = subject.run!
-        sleep(0.1)
-        @thread.should be_a(Thread)
-      end
-    end
-
-    context 'module #run!' do
-
-      let(:clazz) do
-        Class.new { include Runnable }
-      end
-
-      after(:each) do
-        @context.runner.stop if @context && @context.runner
-        @context.thread.kill if @context && @context.thread
-      end
-
-      it 'creates a new runner' do
-        clazz.should_receive(:new).once.with(no_args())
-        @context = clazz.run!
-        sleep(0.1)
-      end
-
-      it 'passes all args to the runner constructor' do
-        args = [1, 2, :three, :four]
-        clazz.should_receive(:new).once.with(*args)
-        @context = clazz.run!(*args)
-        sleep(0.1)
-      end
-
-      it 'passes a block argument to the runner constructor' do
-        @expected = false
-        @context = runnable.run!{ @expected = true }
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'creates a new thread' do
-        Thread.should_receive(:new).with(any_args()).and_return(nil)
-        @context = runnable.run!
-        sleep(0.1)
-      end
-
-      it 'runs the runner on the new thread' do
-        @context = runnable.run!
-        sleep(0.1)
-        @context.runner.thread.should_not eq Thread.current
-        @context.runner.thread.should eq @context.thread
-        @context.thread.should_not eq Thread.current
-      end
-
-      it 'returns a context object on success' do
-        @context = runnable.run!
-        sleep(0.1)
-        @context.should be_a(Runnable::Context)
-      end
-
-      it 'returns nil on failure' do
-        Thread.stub(:new).with(any_args()).and_raise(StandardError)
-        @context = runnable.run!
-        sleep(0.1)
-        @context.should be_nil
-      end
-    end
-  end
-end