concurrent-ruby 0.6.1 → 0.7.0.rc0

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

data/spec/concurrent/scheduled_task_spec.rb

@@ -1,340 +0,0 @@
-require 'spec_helper'
-require 'timecop'
-require_relative 'dereferenceable_shared'
-require_relative 'obligation_shared'
-require_relative 'observable_shared'
-
-module Concurrent
-
-  describe ScheduledTask do
-    context 'behavior' do
-
-      # obligation
-
-      let!(:fulfilled_value) { 10 }
-      let!(:rejected_reason) { StandardError.new('mojo jojo') }
-
-      let(:pending_subject) do
-        ScheduledTask.new(1){ fulfilled_value }.execute
-      end
-
-      let(:fulfilled_subject) do
-        latch = Concurrent::CountDownLatch.new(1)
-        task = ScheduledTask.new(0.1){ latch.count_down; fulfilled_value }.execute
-        latch.wait(1)
-        sleep(0.1)
-        task
-      end
-
-      let(:rejected_subject) do
-        latch = Concurrent::CountDownLatch.new(1)
-        task = ScheduledTask.new(0.1){ latch.count_down; raise rejected_reason }.execute
-        latch.wait(1)
-        sleep(0.1)
-        task
-      end
-
-      it_should_behave_like :obligation
-
-      # dereferenceable
-
-      def dereferenceable_subject(value, opts = {})
-        ScheduledTask.execute(0.1, opts){ value }.tap{ sleep(0.2) }
-      end
-
-      def dereferenceable_observable(opts = {})
-        ScheduledTask.new(0.1, opts){ 'value' }
-      end
-
-      def execute_dereferenceable(subject)
-        subject.execute
-        sleep(0.2)
-      end
-
-      it_should_behave_like :dereferenceable
-
-      # observable
-
-      subject{ ScheduledTask.new(0.1){ nil } }
-
-      def trigger_observable(observable)
-        observable.execute
-        sleep(0.2)
-      end
-
-      it_should_behave_like :observable
-    end
-
-    context '#initialize' do
-
-      it 'accepts a number of seconds (from now) as the schedule time' do
-        Timecop.freeze do
-          now = Time.now
-          task = ScheduledTask.new(60){ nil }.execute
-          task.schedule_time.to_i.should eq now.to_i + 60
-        end
-      end
-
-      it 'accepts a time object as the schedule time' do
-        schedule = Time.now + (60*10)
-        task = ScheduledTask.new(schedule){ nil }.execute
-        task.schedule_time.should eq schedule
-      end
-
-      it 'raises an exception when seconds is less than zero' do
-        expect {
-          ScheduledTask.new(-1){ nil }
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'raises an exception when schedule time is in the past' do
-        expect {
-          ScheduledTask.new(Time.now - 60){ nil }
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'raises an exception when no block given' do
-        expect {
-          ScheduledTask.new(1)
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'sets the initial state to :unscheduled' do
-        task = ScheduledTask.new(1){ nil }
-        task.should be_unscheduled
-      end
-
-      it 'sets the #schedule_time to nil prior to execution' do
-        task = ScheduledTask.new(1){ nil }
-        task.schedule_time.should be_nil
-      end
-    end
-
-    context 'instance #execute' do
-
-      it 'does nothing unless the state is :unscheduled' do
-        Thread.should_not_receive(:new).with(any_args)
-        task = ScheduledTask.new(1){ nil }
-        task.instance_variable_set(:@state, :pending)
-        task.execute
-        task.instance_variable_set(:@state, :rejected)
-        task.execute
-        task.instance_variable_set(:@state, :fulfilled)
-        task.execute
-      end
-
-      it 'calculates the #schedule_time on execution' do
-        Timecop.freeze do
-          now = Time.now
-          task = ScheduledTask.new(5){ nil }
-          Timecop.travel(10)
-          task.execute
-          task.schedule_time.to_i.should eq now.to_i + 15
-        end
-      end
-
-      it 'raises an exception if expected schedule time is in the past' do
-        Timecop.freeze do
-          schedule = Time.now + (10)
-          task = ScheduledTask.new(schedule){ nil }
-          Timecop.travel(60)
-          expect {
-            task.execute
-          }.to raise_error(ArgumentError)
-        end
-      end
-
-      it 'sets the sate to :pending' do
-        task = ScheduledTask.new(1){ nil }
-        task.execute
-        task.should be_pending
-      end
-
-      it 'returns self' do
-        task = ScheduledTask.new(1){ nil }
-        task.execute.should eq task
-      end
-    end
-
-    context 'class #execute' do
-
-      it 'creates a new ScheduledTask' do
-        task = ScheduledTask.execute(1){ nil }
-        task.should be_a(ScheduledTask)
-      end
-
-      it 'passes the block to the new ScheduledTask' do
-        @expected = false
-        task = ScheduledTask.execute(0.1){ @expected = true }
-        task.value(1)
-        @expected.should be_true
-      end
-
-      it 'calls #execute on the new ScheduledTask' do
-        task = ScheduledTask.new(0.1){ nil }
-        ScheduledTask.stub(:new).with(any_args).and_return(task)
-        task.should_receive(:execute).with(no_args)
-        ScheduledTask.execute(0.1){ nil }
-      end
-    end
-
-    context '#cancel' do
-
-      it 'returns false if the task has already been performed' do
-        task = ScheduledTask.new(0.1){ 42 }.execute
-        task.value(1)
-        task.cancel.should be_false
-      end
-
-      it 'returns false if the task is already in progress' do
-        latch = Concurrent::CountDownLatch.new(1)
-        task = ScheduledTask.new(0.1) {
-          latch.count_down
-          sleep(1)
-        }.execute
-        latch.wait(1)
-        task.cancel.should be_false
-      end
-
-      it 'cancels the task if it has not yet scheduled' do
-        latch = Concurrent::CountDownLatch.new(1)
-        task = ScheduledTask.new(0.1){ latch.count_down }
-        task.cancel
-        task.execute
-        latch.wait(0.3).should be_false
-      end
-
-
-      it 'cancels the task if it has not yet started' do
-        latch = Concurrent::CountDownLatch.new(1)
-        task = ScheduledTask.new(0.3){ latch.count_down }.execute
-        sleep(0.1)
-        task.cancel
-        latch.wait(0.5).should be_false
-      end
-
-      it 'returns true on success' do
-        task = ScheduledTask.new(10){ nil }.execute
-        sleep(0.1)
-        task.cancel.should be_true
-      end
-
-      it 'sets the state to :cancelled when cancelled' do
-        task = ScheduledTask.new(10){ 42 }.execute
-        sleep(0.1)
-        task.cancel
-        task.should be_cancelled
-      end
-    end
-
-    context 'execution' do
-
-      it 'sets the state to :in_progress when the task is running' do
-        latch = Concurrent::CountDownLatch.new(1)
-        task = ScheduledTask.new(0.1) {
-          latch.count_down
-          sleep(1)
-        }.execute
-        latch.wait(1)
-        task.should be_in_progress
-      end
-    end
-
-    context 'observation' do
-
-      let(:clazz) do
-        Class.new do
-          attr_reader :value
-          attr_reader :reason
-          attr_reader :count
-          attr_reader :latch
-          def initialize
-            @latch = Concurrent::CountDownLatch.new(1)
-          end
-          def update(time, value, reason)
-            @count = @count.to_i + 1
-            @value = value
-            @reason = reason
-            @latch.count_down
-          end
-        end
-      end
-
-      let(:observer) { clazz.new }
-
-      it 'returns true for an observer added while :unscheduled' do
-        task = ScheduledTask.new(0.1){ 42 }
-        task.add_observer(observer).should be_true
-      end
-
-      it 'returns true for an observer added while :pending' do
-        task = ScheduledTask.new(0.1){ 42 }.execute
-        task.add_observer(observer).should be_true
-      end
-
-      it 'returns true for an observer added while :in_progress' do
-        task = ScheduledTask.new(0.1){ sleep(1); 42 }.execute
-        sleep(0.2)
-        task.add_observer(observer).should be_true
-      end
-
-      it 'returns false for an observer added once :cancelled' do
-        task = ScheduledTask.new(1){ 42 }
-        task.cancel
-        task.add_observer(observer).should be_false
-      end
-
-      it 'returns false for an observer added once :fulfilled' do
-        task = ScheduledTask.new(0.1){ 42 }.execute
-        task.value(1)
-        task.add_observer(observer).should be_false
-      end
-
-      it 'returns false for an observer added once :rejected' do
-        task = ScheduledTask.new(0.1){ raise StandardError }.execute
-        task.value(0.2)
-        task.add_observer(observer).should be_false
-      end
-
-      it 'notifies all observers on fulfillment' do
-        task = ScheduledTask.new(0.1){ 42 }.execute
-        task.add_observer(observer)
-        observer.latch.wait(1)
-        observer.value.should == 42
-        observer.reason.should be_nil
-      end
-
-      it 'notifies all observers on rejection' do
-        task = ScheduledTask.new(0.1){ raise StandardError }.execute
-        task.add_observer(observer)
-        observer.latch.wait(1)
-        observer.value.should be_nil
-        observer.reason.should be_a(StandardError)
-      end
-
-      it 'does not notify an observer added after fulfillment' do
-        observer.should_not_receive(:update).with(any_args)
-        task = ScheduledTask.new(0.1){ 42 }.execute
-        task.value(1)
-        task.add_observer(observer)
-        sleep(0.1)
-      end
-
-      it 'does not notify an observer added after rejection' do
-        observer.should_not_receive(:update).with(any_args)
-        task = ScheduledTask.new(0.1){ raise StandardError }.execute
-        task.value(1)
-        task.add_observer(observer)
-        sleep(0.1)
-      end
-
-      it 'does not notify an observer added after cancellation' do
-        observer.should_not_receive(:update).with(any_args)
-        task = ScheduledTask.new(0.1){ 42 }.execute
-        task.cancel
-        task.add_observer(observer)
-        task.value(1)
-      end
-    end
-  end
-end