aws-flow 1.0.5 → 1.0.6

data/test/aws/decider_spec.rb

@@ -30,6 +30,14 @@ class TrivialConverter
   end
 end
 
+class FakeLogger
+  attr_accessor :level
+  def info(s); end
+  def debug(s); end
+  def warn(s); end
+  def error(s); end
+end
+
 class FakePage
   def initialize(object); @object = object; end
   def page; @object; end
@@ -1095,7 +1103,7 @@ describe "FakeHistory" do
     BadWorkflow.trace.should == [:start, :middle, :end]
   end
 
-  it "makes sure that signal works correctly" do
+  it "makes sure that raising an error properly fails a workflow" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
       def get_decision_tasks
         fake_workflow_type =  FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
@@ -1185,6 +1193,85 @@ describe "FakeHistory" do
     worker.start
     swf_client.trace.first[:decisions].first[:start_timer_decision_attributes][:start_to_fire_timeout].should == "5"
   end
+
+  it "ensures that CompleteWorkflowExecutionFailed is correctly handled" do
+    class FakeAttribute
+      def initialize(data)
+        @data = data
+      end
+      def method_missing(method_name, *args, &block)
+        if @data.keys.include? method_name
+          return @data[method_name]
+        end
+        super
+      end
+    end
+
+    class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+      def get_decision_tasks
+        fake_workflow_type = FakeWorkflowType.new(nil, "CompleteWorkflowExecutionFailedWorkflow.entry_point", "1")
+        TestHistoryWrapper.new(fake_workflow_type,
+                               [
+                                TestHistoryEvent.new("WorkflowExecutionStarted", 1, {}),
+                                TestHistoryEvent.new("DecisionTaskScheduled", 2, {}),
+                                TestHistoryEvent.new("DecisionTaskStarted", 3, {}),
+                                TestHistoryEvent.new("DecisionTaskCompleted", 4, {}),
+                                TestHistoryEvent.new("ActivityTaskScheduled", 5, {:activity_id => "Activity1"}),
+                                TestHistoryEvent.new("ActivityTaskScheduled", 6, {:activity_id => "Activity2"}),
+                                TestHistoryEvent.new("ActivityTaskStarted", 7, {}),
+                                TestHistoryEvent.new("ActivityTaskFailed", 8, {:scheduled_event_id => 5}),
+                                TestHistoryEvent.new("DecisionTaskScheduled", 9, {}),
+                                TestHistoryEvent.new("ActivityTaskStarted", 10, {}),
+                                TestHistoryEvent.new("ActivityTaskFailed", 11, {:scheduled_event_id => 6}),
+                                TestHistoryEvent.new("DecisionTaskStarted", 12, {}),
+                                TestHistoryEvent.new("DecisionTaskCompleted", 13, {}),
+                                TestHistoryEvent.new("RequestCancelActivityTaskFailed", 14, FakeAttribute.new({:activity_id => "Activity2"}) ) ,
+                                TestHistoryEvent.new("CompleteWorkflowExecutionFailed", 15, {}),
+                                TestHistoryEvent.new("DecisionTaskScheduled", 16, {}),
+                               ])
+      end
+    end
+    workflow_type_object = double("workflow_type", :name => "CompleteWorkflowExecutionFailedWorkflow.entry_point", :start_execution => "" )
+    domain = FakeDomain.new(workflow_type_object)
+
+    class CompleteWorkflowExecutionFailedActivity
+      extend Activity
+      activity :run_activity1
+      def run_activity1; raise StandardError; end
+    end
+    class CompleteWorkflowExecutionFailedWorkflow
+      extend Workflows
+      workflow(:entry_point) { {:version => "1"} }
+      activity_client(:activity) { {:version => "1", :prefix_name => "CompleteWorkflowExecutionFailedActivity" } }
+      def entry_point
+        child_futures = []
+        error_handler do |t|
+          t.begin do
+            child_futures << activity.send_async(:run_activity1)
+            child_futures << activity.send_async(:run_activity1)
+            wait_for_all(child_futures)
+          end
+          t.rescue(Exception) do |error|
+          end
+          t.ensure do
+          end
+        end
+      end
+    end
+    swf_client = FakeServiceClient.new
+    task_list = "CompleteWorkflowExecutionFailedWorkflow_tasklist"
+    my_workflow_factory = workflow_factory(swf_client, domain) do |options|
+      options.workflow_name = "CompleteWorkflowExecutionFailedWorkflow"
+      options.execution_start_to_close_timeout = 3600
+      options.task_list = task_list
+    end
+    worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list)
+    worker.add_workflow_implementation(CompleteWorkflowExecutionFailedWorkflow)
+    my_workflow = my_workflow_factory.get_client
+    workflow_execution = my_workflow.start_execution
+    worker.start
+    swf_client.trace.first[:decisions].first[:decision_type].should == "CompleteWorkflowExecution"
+  end
 end
 
 describe "Misc tests" do
@@ -1224,6 +1311,33 @@ describe "Misc tests" do
   end
 
 
+  it "ensures that using send_async doesn't mutate the original hash" do
+    class GenericClientTest < GenericClient
+      def call_options(*args, &options)
+        options.call
+      end
+    end
+    # Instead of setting up the fiber, just pretend we're internal
+    module Utilities
+      class << self
+        alias_method :old_is_external, :is_external
+        def is_external
+          return false
+        end
+      end
+    end
+    generic_client = GenericClientTest.new
+    previous_hash = {:key => :value}
+    previous_hash_copy = previous_hash.dup
+    generic_client.send_async(:call_options) { previous_hash }
+    # Put is_external back before we have a chance of failing
+    module Utilities
+      class << self
+        alias_method :is_external, :old_is_external
+      end
+    end
+    previous_hash.should == previous_hash_copy
+  end
 end
 
 describe FlowConstants do
@@ -1280,40 +1394,43 @@ class TestActivityWorker < ActivityWorker
 
   attr_accessor :executor
   def initialize(service, domain, task_list, forking_executor, *args, &block)
-    super(service, domain, task_list, *args)
+    super(service, domain, task_list, *args, &block)
     @executor = forking_executor
   end
 end
 
 describe ActivityWorker do
 
-  it "will test whether the ActivityWorker shuts down cleanly when an interrupt is received" do
-
-    task_list = "TestWorkflow_tasklist"
-    service = FakeServiceClient.new
-    workflow_type_object = double("workflow_type", :name => "TestWorkflow.entry_point", :start_execution => "" )
-    domain = FakeDomain.new(workflow_type_object)
-    forking_executor = ForkingExecutor.new
-    activity_worker = TestActivityWorker.new(service, domain, task_list, forking_executor)
-
-    activity_worker.add_activities_implementation(TestActivity)
-    # Starts the activity worker in a forked process. Also, attaches an at_exit handler to the process. When the process
-    # exits, the handler checks whether the executor's internal is_shutdown variable is set correctly or not.
-    pid = fork do
-      at_exit {
-        activity_worker.executor.is_shutdown.should == true
-      }
-      activity_worker.start true
-    end
-    # Adding a sleep to let things get setup correctly (not ideal but going with this for now)
-    sleep 1
-    # Send an interrupt to the child process
-    Process.kill("INT", pid)
-    status = Process.waitall
-    status[0][1].success?.should be_true
-  end
-
-  # This method will take a long time to run, allowing us to test our shutdown scenarios
+  # it "will test whether the ActivityWorker shuts down cleanly when an interrupt is received" do
+
+  #   task_list = "TestWorkflow_tasklist"
+  #   service = FakeServiceClient.new
+  #   workflow_type_object = double("workflow_type", :name => "TestWorkflow.entry_point", :start_execution => "" )
+  #   domain = FakeDomain.new(workflow_type_object)
+  #   forking_executor = ForkingExecutor.new
+  #   activity_worker = TestActivityWorker.new(service, domain, task_list, forking_executor) { {:logger => FakeLogger.new} }
+
+  #   activity_worker.add_activities_implementation(TestActivity)
+  #   # Starts the activity worker in a forked process. Also, attaches an at_exit
+  #   # handler to the process. When the process exits, the handler checks whether
+  #   # the executor's internal is_shutdown variable is set correctly or not.
+  #   pid = fork do
+  #     at_exit {
+  #       activity_worker.executor.is_shutdown.should == true
+  #     }
+  #     activity_worker.start true
+  #   end
+  #   # Adding a sleep to let things get setup correctly (not ideal but going with
+  #   # this for now)
+  #   #sleep 1
+  #   # Send an interrupt to the child process
+  #   Process.kill("INT", pid)
+  #   status = Process.waitall
+  #   status[0][1].success?.should be_true
+  # end
+
+  # This method will take a long time to run, allowing us to test our shutdown
+  # scenarios
   def dumb_fib(n)
     n < 1 ? 1 : dumb_fib(n - 1) + dumb_fib(n - 2)
   end
@@ -1324,20 +1441,23 @@ describe ActivityWorker do
     workflow_type_object = double("workflow_type", :name => "TestWorkflow.entry_point", :start_execution => "" )
     domain = FakeDomain.new(workflow_type_object)
     forking_executor = ForkingExecutor.new
-    activity_worker = TestActivityWorker.new(service, domain, task_list, forking_executor)
+    activity_worker = TestActivityWorker.new(service, domain, task_list, forking_executor) { {:logger => FakeLogger.new} }
 
     activity_worker.add_activities_implementation(TestActivity)
-    # Starts the activity worker in a forked process. Also, executes a task using the forking executor of the activity
-    # worker. The executor will create a child process to run that task. The task (dumb_fib) is purposefully designed to
-    # be long running so that we can test our shutdown scenario.
+    # Starts the activity worker in a forked process. Also, executes a task
+    # using the forking executor of the activity worker. The executor will
+    # create a child process to run that task. The task (dumb_fib) is
+    # purposefully designed to be long running so that we can test our shutdown
+    # scenario.
     pid = fork do
       activity_worker.executor.execute {
         dumb_fib(1000)
       }
       activity_worker.start true
     end
-    # Adding a sleep to let things get setup correctly (not idea but going with this for now)
-    sleep 2
+    # Adding a sleep to let things get setup correctly (not idea but going with
+    # this for now)
+    sleep 3
     # Send 2 interrupts to the child process
     2.times { Process.kill("INT", pid); sleep 3 }
     status = Process.waitall

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

@@ -13,7 +13,36 @@
 # permissions and limitations under the License.
 ##
 
-require 'rubygems'
+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
+
+end
 
 class WorkflowGenerator
   class << self