aws-flow 1.0.0 → 1.0.1

data/aws-flow-core/test/aws/external_task_spec.rb

@@ -1,197 +0,0 @@
-##
-# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License").
-# You may not use this file except in compliance with the License.
-# A copy of the License is located at
-#
-#  http://aws.amazon.com/apache2.0
-#
-# or in the "license" file accompanying this file. This file is distributed
-# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
-# express or implied. See the License for the specific language governing
-# permissions and limitations under the License.
-##
-
-describe "ExternalTask#alive?" do
-  let(:scope) { AsyncScope.new }
-  let(:simple_unit) do
-    ExternalTask.new(:parent => scope ) do |t|
-      t.initiate_task { |h| 2 + 2; h.complete }
-    end
-  end
-  it "tells you that ExternalTask is alive before the ExternalTask starts" do
-    simple_unit.alive?.should == true
-  end
-  it "tells you that ExternalTask is not alive once ExternalTask has exited" do
-    task_context = TaskContext.new(:parent => scope.get_closest_containing_scope, :task => simple_unit)
-    simple_unit.resume
-    simple_unit.alive?.should == false
-  end
-end
-
-describe ExternalTask do
-  let(:trace) { [] }
-
-  before(:each) do
-
-    class ExternalTaskException < Exception; end
-    @this_scope = AsyncScope.new() do
-    end
-    @this_task = ExternalTask.new(:parent => @this_scope) do |t|
-      t.cancellation_handler { |h, cause| h.fail(cause) }
-      t.initiate_task { |h| trace << :task_started; h.complete }
-    end
-    task_context = TaskContext.new(:parent => @this_scope.get_closest_containing_scope, :task => @this_task)
-    @this_scope << @this_task
-  end
-
-  it "should complete okay" do
-
-    @this_scope.eventLoop
-    trace.should == [:task_started]
-  end
-
-  it "cancelling should cause an exception to be raised" do
-    @this_task.cancel(ExternalTaskException.new)
-    expect { @this_scope.eventLoop }.to raise_error ExternalTaskException
-  end
-
-  it "shouldn't cancel an already completed task" do
-    @this_scope.eventLoop
-    @this_task.cancel(Exception)
-  end
-
-  describe "cancelling an external task without a cancellation handler" do
-    before(:each) do
-      @this_scope = AsyncScope.new() do
-
-      end
-      @this_task = ExternalTask.new() do |t|
-        t.initiate_task { |h| trace << :task_started; h.complete }
-      end
-      @this_scope << @this_task
-    end
-    it "ensures that calling cancel results in no error" do
-      task_context = TaskContext.new(:parent => @this_scope.get_closest_containing_scope, :task => @this_task)
-      @this_task.cancel(ExternalTaskException)
-    end
-    it "ensures that attempting to run a cancelled task has no effect" do
-      task_context = TaskContext.new(:parent => @this_scope.get_closest_containing_scope, :task => @this_task)
-      @this_task.cancel(ExternalTaskException)
-      @this_scope.eventLoop
-      trace.should == []
-    end
-  end
-
-  it "ensures that raising in the cancellation handler is handled " do
-    scope = AsyncScope.new
-    external_task = ExternalTask.new() do |t|
-      t.initiate_task { |h| h.complete }
-      t.cancellation_handler { |h, cause| raise "Oh no!" }
-    end
-    scope << external_task
-    task_context = TaskContext.new(:parent => scope.get_closest_containing_scope, :task => external_task)
-    external_task.cancel(Exception)
-    expect { scope.eventLoop }.to raise_error /Oh no!/
-  end
-
-  it "ensures that cancelling a completed task is handled" do
-    @this_scope.eventLoop
-    @this_task.cancel(Exception)
-  end
-
-  it "ensures that cancelling a cancelled task is handled" do
-    @this_scope.eventLoop
-    @this_task.cancel(Exception)
-    @this_task.cancel(Exception)
-  end
-
-  it "ensures that failing a task after completion raises an error" do
-    @this_scope = AsyncScope.new() do
-    end
-    @this_task = ExternalTask.new() do |t|
-      t.cancellation_handler { |h| h.fail }
-      t.initiate_task { |h| trace << :task_started; h.complete; h.fail(Exception) }
-    end
-    task_context = TaskContext.new(:parent => @this_scope.get_closest_containing_scope, :task => @this_task)
-    @this_scope << @this_task
-    expect { @this_scope.eventLoop }.to raise_error /Already completed/
-  end
-
-  it "ensures that completing an external_task allows the asyncScope to move forward" do
-    @handle = nil
-    @this_scope = AsyncScope.new() do
-      external_task do |t|
-        t.cancellation_handler {|h| h.fail}
-        t.initiate_task {|h| @handle = h }
-      end
-    end
-    @this_scope.eventLoop
-    @this_scope.is_complete?.should == false
-    @handle.complete
-    @this_scope.eventLoop
-    @this_scope.is_complete?.should == true
-  end
-end
-
-describe "external_task function" do
-
-  it "ensures that cancelling will raise the externalTasks cancellation handler" do
-    trace = []
-    this_scope = AsyncScope.new() do
-      trace << :async_start
-      external_task do |t|
-        t.cancellation_handler {|h, cause| trace << :cancellation_handler; h.complete }
-        t.initiate_task { |h|  trace << :external_task}
-      end
-      task { trace << :task; raise IllegalStateException }
-      trace << :async_done
-    end
-    expect { this_scope.eventLoop }.to raise_error IllegalStateException
-    trace.should == [:async_start, :async_done, :external_task, :task, :cancellation_handler]
-  end
-
-  it "tests explicit cancellation of BRE cancelling externalTask correctly" do
-    handle_future = Future.new
-    trace = []
-
-    scope = AsyncScope.new do
-      trace << :async_start
-      bre = error_handler do |t|
-        t.begin do
-          external_task do |t|
-            trace << :external_task;
-            t.cancellation_handler {|h, cause| trace << :cancellation_handler; h.complete}
-            t.initiate_task { |h|  handle_future.set(h) }
-          end
-
-          task do
-            trace << :in_the_cancel_task
-            handle_future.get
-            bre.cancel(nil)
-          end
-        end
-        t.rescue(Exception) { |e| e.class.should <= CancellationException }
-      end
-
-      trace << :async_done
-    end
-    scope.eventLoop
-    trace.should == [:async_start, :async_done, :external_task, :in_the_cancel_task, :cancellation_handler]
-  end
-
-  it "ensures that having an external_task within an AsyncScope works" do
-    trace = []
-    this_scope = AsyncScope.new() do
-      external_task do |t|
-        t.cancellation_handler { |h| h.fail }
-        t.initiate_task { |h| trace << :task_started; h.complete; }
-      end
-    end
-    trace.should == []
-    this_scope.eventLoop
-    trace.should == [:task_started]
-  end
-
-end

data/aws-flow-core/test/aws/factories.rb

@@ -1,52 +0,0 @@
-##
-# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License").
-# You may not use this file except in compliance with the License.
-# A copy of the License is located at
-#
-#  http://aws.amazon.com/apache2.0
-#
-# or in the "license" file accompanying this file. This file is distributed
-# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
-# express or implied. See the License for the specific language governing
-# permissions and limitations under the License.
-##
-
-require 'rubygems'
-require 'factory_girl'
-require 'aws/flow'
-include AWS::Flow::Core
-
-
-class FlowFactory
-
-  attr_accessor :async_scope
-  def generate_BRE(options = {})
-    scope = generate_scope
-    bre = BeginRescueEnsure.new(:parent => scope.root_context)
-    begin_statement = options[:begin] ? options[:begin] : lambda {}
-    rescue_statement = options[:rescue] ? options[:rescue] : lambda {|x| }
-    rescue_exception = options[:rescue_exceptions] ? options[:rescue_exceptions] : StandardError
-    ensure_statement = options[:ensure] ? options[:ensure] : lambda {}
-    bre.begin begin_statement
-    bre.rescue(rescue_exception, rescue_statement)
-    bre.ensure ensure_statement
-    scope << bre
-    bre
-  end
-
-  def generate_scope(options = {})
-    lambda = options[:lambda] || lambda {}
-    @async_scope ||= AsyncScope.new do
-      lambda.call
-    end
-    return @async_scope
-  end
-
-  def generate_daemon_task(options = {})
-    scope = generate_scope
-    task = DaemonTask.new
-
-  end
-end

data/aws-flow-core/test/aws/fiber_condition_variable_spec.rb

@@ -1,163 +0,0 @@
-##
-# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License").
-# You may not use this file except in compliance with the License.
-# A copy of the License is located at
-#
-#  http://aws.amazon.com/apache2.0
-#
-# or in the "license" file accompanying this file. This file is distributed
-# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
-# express or implied. See the License for the specific language governing
-# permissions and limitations under the License.
-##
-
-describe FiberConditionVariable do
-  let(:condition) { FiberConditionVariable.new }
-  let(:trace) { [] }
-
-  it "blocks a Fiber and wakes it up on signal" do
-    scope = AsyncScope.new do
-      task do
-        trace << :first
-        condition.wait
-        # TODO technically this should only be checked in a TaskContext test;
-        # a Future test would just make sure that this comes after :second
-        trace << :fourth
-      end
-
-      task do
-        trace << :second
-        condition.signal
-        trace << :third
-      end
-    end
-
-    scope.eventLoop
-    trace.should == [:first, :second, :third, :fourth]
-  end
-
-  it "blocks multiple Fibers and wakes them up on signal" do
-    scope = AsyncScope.new do
-      task do
-        trace << :first
-        condition.wait
-        # TODO technically this should only be checked in a TaskContext test;
-        # a Future test would just make sure that this comes after :second
-        trace << :sixth
-      end
-
-      task do
-        trace << :second
-        condition.wait
-        trace << :seventh
-      end
-
-      task do
-        trace << :third
-        condition.signal
-        trace << :fourth
-        condition.signal
-        trace << :fifth
-      end
-    end
-
-    scope.eventLoop
-    trace.should == [:first, :second, :third, :fourth, :fifth, :sixth, :seventh]
-  end
-
-  it "blocks a Fiber and wakes it up on broadcast" do
-    scope = AsyncScope.new do
-      task do
-        trace << :first
-        condition.wait
-        # TODO technically this should only be checked in a TaskContext test;
-        # a Future test would just make sure that this comes after :second
-        trace << :fourth
-      end
-
-      task do
-        trace << :second
-        condition.broadcast
-        trace << :third
-      end
-    end
-    scope.eventLoop
-    trace.should == [:first, :second, :third, :fourth]
-  end
-
-  it "blocks multiple Fibers and wakes them up on broadcast" do
-    scope = AsyncScope.new do
-      task do
-        trace << :first
-        condition.wait
-        # TODO technically this should only be checked in a TaskContext test;
-        # a Future test would just make sure that this comes after :second
-        trace << :fifth
-      end
-
-      task do
-        trace << :second
-        condition.wait
-        trace << :sixth
-      end
-
-      task do
-        trace << :third
-        condition.broadcast
-        trace << :fourth
-      end
-    end
-
-    scope.eventLoop
-    trace.should == [:first, :second, :third, :fourth, :fifth, :sixth]
-  end
-
-
-
-  [:broadcast, :signal].each do |method_to_test|
-    it "ensures that multiple broadcasts cannot cause multiple runs of fibers" do
-      trace = []
-      scope = AsyncScope.new do
-        task do
-          trace << :first
-          condition.wait
-          trace << :fourth
-        end
-        task do
-          trace << :second
-          condition.send method_to_test
-          condition.send method_to_test
-          trace << :third
-        end
-      end
-      scope.eventLoop
-      trace.should == [:first, :second, :third, :fourth]
-    end
-
-    it "ensures that calling #{method_to_test} with no waiters doesn't error" do
-      condition.send method_to_test
-    end
-
-    it "ensures that #{method_to_test}ing a task that is dead has no effect" do
-      condition = FiberConditionVariable.new
-      trace = []
-      scope = AsyncScope.new
-      a = Task.new(scope.root_context) do
-        trace << :first
-        condition.wait
-        trace << :should_never_be_hit
-      end
-      b = Task.new(scope.root_context) do
-        trace << :second
-        condition.send(method_to_test)
-        trace << :third
-      end
-      a.resume
-      a.should_receive(:alive?).and_return(false)
-      b.resume
-      trace.should == [:first, :second, :third]
-    end
-  end
-end

data/aws-flow-core/test/aws/fiber_spec.rb

@@ -1,78 +0,0 @@
-##
-# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License").
-# You may not use this file except in compliance with the License.
-# A copy of the License is located at
-#
-#  http://aws.amazon.com/apache2.0
-#
-# or in the "license" file accompanying this file. This file is distributed
-# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
-# express or implied. See the License for the specific language governing
-# permissions and limitations under the License.
-##
-
-describe Fiber do
-  it "makes sure that Fibers behave the same" do
-    root_fiber = Fiber.current
-    scope = AsyncScope.new() do
-      p "yay"
-    end
-    Fiber.current.should == root_fiber
-  end
-  it "makes sure that FiberLocal variables inherit correctly" do
-    scope = AsyncScope.new() do
-      FlowFiber.current[:test] = 5
-      FlowFiber.current[:test].should == 5
-      task do
-        FlowFiber.current[:test].should == 5
-      end
-    end
-    scope.eventLoop
-  end
-
-  it "makes sure that fiber values get unset correctly" do
-    first_scope = AsyncScope.new do
-      FlowFiber.current[:test] = 5
-      FlowFiber.current[:test].should == 5
-    end
-    second_scope = AsyncScope.new do
-      @current_thread = FlowFiber.current
-      FlowFiber.current[:test] = 5
-      FlowFiber.current[:test].should == 5
-      task do
-        task do
-          FlowFiber.unset(FlowFiber.current, :test)
-        end
-      end
-      FlowFiber.current[:test]
-    end
-    first_scope.eventLoop
-    second_scope.eventLoop
-    FlowFiber[@current_thread][:test].should == nil
-  end
-
-  it "makes sure that fibers pass by reference" do
-    class CustomObject
-      attr_accessor :this_stuff
-    end
-    x = CustomObject.new
-    @trace = []
-    first_fiber = FlowFiber.new do
-      x.this_stuff = 6
-      Fiber.yield
-      @trace << x.this_stuff
-    end
-
-    second_fiber = FlowFiber.new do
-      x.this_stuff = x.this_stuff * 2
-      @trace << x.this_stuff
-    end
-    first_fiber.resume
-    second_fiber.resume
-    first_fiber.resume
-    @trace.select{|x| x == 12}.length == 2
-
-  end
-end