aws-flow 1.0.5 → 1.0.6

data/test/aws/future_spec.rb

@@ -0,0 +1,210 @@
+##
+# 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 Future do
+  let(:future) { Future.new }
+  let(:trace) { [] }
+  it "throws an exception when set multiple times" do
+    future.set(:foo)
+    expect { future.set(:bar) }.to raise_error AlreadySetException
+  end
+
+  it "returns the value which was set" do
+    value = :foo
+    future.set(value)
+    future.get.should == value
+  end
+
+  it "blocks a task until a value is ready" do
+    scope = AsyncScope.new do
+      task do
+        trace << :first
+        future.get
+        # 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
+        future.set(:foo)
+        trace << :third
+      end
+    end
+
+    scope.eventLoop
+    trace.should == [:first, :second, :third, :fourth]
+  end
+
+  it "blocks multiple Fibers until a value is ready" do
+    scope = AsyncScope.new do
+      task do
+        trace << :first
+        future.get
+        trace << :fifth
+      end
+
+      task do
+        trace << :second
+        future.get
+        trace << :sixth
+      end
+
+      task do
+        trace << :third
+        future.set(:foo)
+        trace << :fourth
+      end
+    end
+    scope.eventLoop
+    trace.should == [:first, :second, :third, :fourth, :fifth, :sixth]
+  end
+
+  it "supports wait_for_any" do
+    scope = AsyncScope.new do
+      f1 = Future.new
+      f2 = Future.new
+      f3 = Future.new
+      trace << :before_task
+      task do
+        trace << :before_set
+        f2.set("bar")
+        trace << :after_set
+      end
+      trace << :before_wait
+
+      f = Future.wait_for_any(f1, f2, f3).first
+      trace << :after_wait
+      f.should == f2
+      f.get.should == "bar"
+    end
+    trace.length.should == 0
+    scope.eventLoop
+    trace.should == [:before_task, :before_wait, :before_set, :after_set, :after_wait]
+  end
+
+  it "supports wait_for_any with all set" do
+    scope = AsyncScope.new do
+      f1 = Future.new
+      f2 = Future.new
+      f3 = Future.new
+      trace << :before_task
+      task do
+        trace << :before_set
+        f2.set("bar")
+        f1.set("baz")
+        f3.set("foo")
+        trace << :after_set
+      end
+      trace << :before_wait
+      r1, r2, r3 = Future.wait_for_any(f1, f2, f3)
+      trace << :after_wait
+      r1.should == f2
+      r1.get.should == "bar"
+      r2.should == f1
+      r2.get.should == "baz"
+      r3.should == f3
+      r3.get.should == "foo"
+    end
+    trace.length.should == 0
+    scope.eventLoop
+    trace.should == [:before_task, :before_wait, :before_set, :after_set, :after_wait]
+  end
+
+  it "supports wait_for_all" do
+    scope = AsyncScope.new do
+      f1 = Future.new
+      f2 = Future.new
+      f3 = Future.new
+      trace << :before_task
+      task do
+        trace << :before_f2_set
+        f2.set("bar")
+        task do
+          trace << :before_f1_set
+          f1.set("baz")
+          task do
+            trace << :before_f3_set
+            f3.set("foo")
+            trace << :after_set
+          end
+        end
+      end
+      trace << :before_wait
+      r1, r2, r3 = Future.wait_for_all(f1, f2, f3)
+      trace << :after_wait
+      r1.should == f2
+      r1.get.should == "bar"
+      r2.should == f1
+      r2.get.should == "baz"
+      r3.should == f3
+      r3.get.should == "foo"
+    end
+    trace.length.should == 0
+    scope.eventLoop
+    trace.should == [:before_task, :before_wait, :before_f2_set, :before_f1_set, :before_f3_set, :after_set, :after_wait]
+  end
+
+  it "supports wait_for_all with no futures" do
+    scope = AsyncScope.new do
+      task do
+        wait_for_all
+      end
+    end
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+  it "supports wait_for_any with no futures" do
+    scope = AsyncScope.new do
+      task do
+        wait_for_any
+      end
+    end
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+  it "supports wait_for_all with a set future" do
+    scope = AsyncScope.new do
+      future = Future.new.set
+      wait_for_all(future)
+    end
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+  it "supports wait_for_any with a set future" do
+    scope = AsyncScope.new do
+      future = Future.new.set
+      wait_for_any(future)
+    end
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+  it "supports wait_for_all with one set future and one not set" do
+    future2 = Future.new
+    scope = AsyncScope.new do
+      future = Future.new.set
+      wait_for_all(future, future2)
+    end
+    scope.eventLoop
+    future2.set
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+end

data/test/aws/integration_spec.rb

@@ -274,12 +274,16 @@ describe "RubyFlowDecider" do
         end
       end
       class SubsequentWorkflow
-        extend Decider
+        extend Workflows
+        workflow :entry_point do
+          {
+            :version => "1",
+          }
+        end
         version "1"
         activity_client :activity do |options|
           options.prefix_name = "SubsequentActivity"
         end
-        entry_point :entry_point
         def entry_point
           activity.run_activity1
           activity.run_activity2
@@ -294,9 +298,18 @@ describe "RubyFlowDecider" do
       worker.register
       activity_worker.register
       sleep 3
-      workflow_id = "basic_subsequent_activities"
-      run_id = @swf.client.start_workflow_execution(:execution_start_to_close_timeout => "3600", :task_list => {:name => task_list}, :task_start_to_close_timeout => "3600", :child_policy => "REQUEST_CANCEL", :workflow_type => {:name => workflow_type_name, :version => "1"}, :workflow_id => workflow_id, :domain => @domain.name.to_s)
-      workflow_execution = AWS::SimpleWorkflow::WorkflowExecution.new(@domain, workflow_id, run_id["runId"])
+
+
+      my_workflow_client = workflow_client(@swf.client, @domain) do
+        {
+          :from_class => "SubsequentWorkflow",
+          :execution_start_to_close_timeout => "3600",
+          :task_list => task_list,
+          :task_start_to_close_timeout => "3600",
+          :child_policy => "REQUEST_CANCEL",
+        }
+      end
+      workflow_execution = my_workflow_client.start_execution
       worker.run_once
       activity_worker.run_once
       worker.run_once
@@ -510,6 +523,29 @@ describe "RubyFlowDecider" do
     @my_workflow_client = workflow_client(@swf.client, @domain) { {:from_class => @workflow_class} }
   end
 
+  it "ensures that an activity returning more than 32k data fails the activity" do
+    general_test(:task_list => "ActivityTaskLargeOutput", :class_name => "ActivityTaskLargeOutput")
+    @activity_class.class_eval do
+      def run_activity1
+        # Make sure we return something that's over 32k. Note this won't
+        # necessarily work with all converters, as it's pretty trivially
+        # compressible
+        return "a" * 33000
+      end
+    end
+    workflow_execution = @my_workflow_client.start_execution
+    @worker.run_once
+    @activity_worker.run_once
+    @worker.run_once
+    history_events = workflow_execution.events.map(&:event_type)
+    # Previously, it would time out, as the failure would include the original
+    # large output that killed the completion call. Thus, we need to check that
+    # we fail the ActivityTask correctly.
+    history_events.should include "ActivityTaskFailed"
+    history_events.last.should == "WorkflowExecutionFailed"
+
+  end
+
   it "ensures that not filling in details/reason for activity_task_failed is handled correctly" do
     general_test(:task_list => "ActivityTaskFailedManually", :class_name => "ActivityTaskFailedManually")
     $task_token = nil
@@ -1274,7 +1310,7 @@ describe "RubyFlowDecider" do
         end
         entry_point :entry_point
         def entry_point(arg)
-          my_workflow_factory = workflow_factory($swf.client, $domain) do |options|
+          client = workflow_client do |options|
             options.workflow_name = "OtherChildWorkflow"
             options.execution_method = "entry_point"
             options.execution_start_to_close_timeout = 3600
@@ -1282,7 +1318,7 @@ describe "RubyFlowDecider" do
             options.version = "1"
             options.task_list = "test2"
           end
-          client = my_workflow_factory.get_client
+
           client.send_async(:start_execution, 5)
           client.send_async(:start_execution, 5)
         end
@@ -1306,6 +1342,7 @@ describe "RubyFlowDecider" do
 
       # Start, start off the child workflow
       worker.run_once
+
       # Run Both child workflows
       worker2.run_once
       worker2.run_once
@@ -1315,6 +1352,7 @@ describe "RubyFlowDecider" do
       # In order to deal with this, we have the following line below
       worker.run_once if workflow_execution.events.map(&:event_type).last == "DecisionTaskCompleted"
       events = workflow_execution.events.map(&:event_type)
+      workflow_execution.events.to_a.last.attributes.result.should_not =~ /secret_access_key/
       events.should include "ChildWorkflowExecutionStarted"
       events.should include "ChildWorkflowExecutionCompleted"
       events.should include "WorkflowExecutionCompleted"
@@ -1575,9 +1613,9 @@ describe "RubyFlowDecider" do
         activity :run_activity1 do |options|
           options.version = "1"
           options.default_task_list = "exponential_test_return_task_list"
-          options.default_task_schedule_to_close_timeout = "5"
-          options.default_task_schedule_to_start_timeout = "5"
-          options.default_task_start_to_close_timeout = "5"
+          options.default_task_schedule_to_close_timeout = "15"
+          options.default_task_schedule_to_start_timeout = "15"
+          options.default_task_start_to_close_timeout = "15"
           options.default_task_heartbeat_timeout = "3600"
         end
         def run_activity1
@@ -1629,50 +1667,50 @@ describe "RubyFlowDecider" do
       workflow_execution = client.start_execution
       worker.run_once
       activity_worker.run_once
-
+      activity_worker.run_once unless workflow_execution.events.map(&:event_type).include? "ActivityTaskCompleted"
       worker.run_once
       workflow_execution.events.map(&:event_type).count("WorkflowExecutionCompleted").should == 1
-
     end
 
     it "makes sure that signals work correctly" do
       class SignalWorkflow
-        class << self
-          attr_accessor :task_list, :trace
+        extend Workflows
+        workflow :entry_point do
+          {
+            :version => "1"
+          }
         end
-        @trace = []
-        extend Decider
-        version "1"
-        def this_signal
+        def this_signal(input)
           @wait.broadcast
+          @input = input
         end
         signal :this_signal
-        entry_point :entry_point
         def entry_point
+          @input = "bad_input"
           @wait ||= FiberConditionVariable.new
           @wait.wait
+          @input.should =~ /new input!/
         end
       end
       task_list = "SignalWorkflow_tasklist"
       worker = WorkflowWorker.new(@swf.client, @domain, task_list)
       worker.add_workflow_implementation(SignalWorkflow)
       worker.register
-      my_workflow_factory = workflow_factory(@swf.client, @domain) do |options|
+      my_workflow_client = workflow_client(@swf.client, @domain) do |options|
         options.workflow_name = "SignalWorkflow"
         options.execution_start_to_close_timeout = 3600
         options.task_list = task_list
         options.task_start_to_close_timeout = 10
         options.child_policy = :request_cancel
       end
-      my_workflow = my_workflow_factory.get_client
       sleep 3
-      workflow_execution = my_workflow.start_execution
+      workflow_execution = my_workflow_client.start_execution
       forking_executor = ForkingExecutor.new(:max_workers => 2)
       worker.run_once
-      my_workflow.signal_workflow_execution("this_signal", workflow_execution)
+
+      my_workflow_client.signal_workflow_execution("this_signal", workflow_execution) { {:input => "new input!"}}
       worker.run_once
       forking_executor.shutdown(1)
-
       workflow_execution.events.map(&:event_type).count("WorkflowExecutionCompleted").should == 1
     end
 
@@ -1931,7 +1969,6 @@ describe "RubyFlowDecider" do
         options.default_task_start_to_close_timeout = "3600"
       end
       def run_activity1(arg)
-        arg.should == 5
         arg + 1
       end
       def run_activity2(arg)
@@ -1942,7 +1979,7 @@ describe "RubyFlowDecider" do
       end
     end
     # Definition of the workflow logic
-    class MyWorkflow
+    class ParallelWorkflow
       extend Decider
       version "1"
       activity_client :activity do |options|
@@ -1983,15 +2020,15 @@ describe "RubyFlowDecider" do
     task_list = "parallel_split_task_list"
     # @swf and @domain are set beforehand with the aws ruby sdk
     worker = WorkflowWorker.new(@swf.client, @domain, task_list)
-    worker.add_workflow_implementation(MyWorkflow)
-    activity_worker = ActivityWorker.new(@swf.client, @domain, task_list)
+    worker.add_workflow_implementation(ParallelWorkflow)
+    activity_worker = ActivityWorker.new(@swf.client, @domain, task_list) { {:use_forking => false}}
     activity_worker.add_activities_implementation(ParallelSplitActivity)
     worker.register
     activity_worker.register
 
     # Get a workflow client to start the workflow
     my_workflow_factory = workflow_factory @swf.client, @domain do |options|
-      options.workflow_name = "MyWorkflow"
+      options.workflow_name = "ParallelWorkflow"
       options.execution_start_to_close_timeout = 3600
       options.task_list = task_list
       options.task_start_to_close_timeout = 10
@@ -2019,6 +2056,7 @@ describe "RubyFlowDecider" do
     # Sleep to give the threads some time to compute, as we'll run right out of
     # the test before they can run otherwise
     sleep 50
+    p workflow_execution.events.to_a
     workflow_execution.events.map(&:event_type).count("WorkflowExecutionCompleted").should == 1
   end
 
@@ -2159,10 +2197,15 @@ describe "RubyFlowDecider" do
 
   it "ensures you cannot schedule more than 99 things in one decision" do
     general_test(:task_list => "schedule_more_than_100", :class_name => "Above100TasksScheduled")
+    @activity_class.class_eval do
+      def run_activity1(arg)
+        arg
+      end
+    end
     @workflow_class.class_eval do
       def entry_point
-        101.times do
-          activity.send_async(:run_activity1)
+        101.times do |i|
+          activity.send_async(:run_activity1, i)
         end
       end
     end
@@ -2223,7 +2266,7 @@ describe "RubyFlowDecider" do
           "did some work in run_activity1"
         end
       end
-      class MyWorkflow
+      class TimeoutWorkflow
         extend Decider
         version "1"
         activity_client :activity do |options|
@@ -2234,17 +2277,18 @@ describe "RubyFlowDecider" do
           activity.run_activity1
         end
       end
-      worker = WorkflowWorker.new(@swf.client, @domain, "timeout_test", MyWorkflow)
+      worker = WorkflowWorker.new(@swf.client, @domain, "timeout_test", TimeoutWorkflow)
       activity_worker = ActivityWorker.new(@swf.client, @domain, "timeout_test", TimeoutActivity)
       worker.register
       activity_worker.register
       my_workflow_factory = workflow_factory @swf.client, @domain do |options|
-        options.workflow_name = "MyWorkflow"
+        options.workflow_name = "TimeoutWorkflow"
         options.execution_start_to_close_timeout = 3600
+        options.task_start_to_close_timeout = 5
         options.task_list = "timeout_test"
       end
       my_workflow_client = my_workflow_factory.get_client
-      num_tests = 50
+      num_tests = 30
       workflow_executions = []
       1.upto(num_tests)  { |i| workflow_executions << my_workflow_client.entry_point }
       forking_executor  = ForkingExecutor.new(:max_workers => 3)
@@ -2252,6 +2296,7 @@ describe "RubyFlowDecider" do
       forking_executor.execute { activity_worker.start }
       sleep 60
       failed_executions = workflow_executions.each{|x| x.events.to_a.last.event_type.should == "WorkflowExecutionCompleted" }
+
     end
   end
 
@@ -2273,7 +2318,7 @@ describe "RubyFlowDecider" do
         version "1"
         entry_point :entry_point
         def entry_point(arg)
-          my_workflow_factory = workflow_factory($swf_client, $domain) do |options|
+          client = workflow_client(@swf_client, @domain) do |options|
             options.workflow_name = "SendAsyncWorkflow"
             options.execution_method = "entry_point"
             options.execution_start_to_close_timeout = 3600
@@ -2281,7 +2326,6 @@ describe "RubyFlowDecider" do
             options.version = "1"
             options.task_list = "client_test_async2"
           end
-          client = my_workflow_factory.get_client
           client.send_async(:start_execution, arg) { {:task_start_to_close_timeout => 35 } }
           client.send_async(:start_execution, arg)
         end
@@ -2297,8 +2341,8 @@ describe "RubyFlowDecider" do
       end
       my_workflow_client = my_workflow_factory.get_client
       workflow_execution = my_workflow_client.entry_point(5)
-
       worker.run_once
+
       internal_worker.run_once
       internal_worker.run_once
       worker.run_once
@@ -2407,7 +2451,7 @@ describe "RubyFlowDecider" do
     end
 
     it "ensures that with_retry does asynchronous blocking correctly" do
-      general_test(:task_list => "with_retry_synch", :class_name => "WithRetrySynchronous")
+      general_test(:task_list => "with_retry_synch", :class_name => "WithRetryAsynchronous")
       @workflow_class.class_eval do
         def entry_point
           with_retry do