aws-flow-core 1.0.0

data/test/aws/external_task_spec.rb

@@ -0,0 +1,197 @@
+##
+# 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/test/aws/factories.rb

@@ -0,0 +1,52 @@
+##
+# 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/test/aws/fiber_condition_variable_spec.rb

@@ -0,0 +1,163 @@
+##
+# 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/test/aws/fiber_spec.rb

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