aws-flow 1.0.4 → 1.0.5

data/Rakefile

@@ -20,9 +20,15 @@ Spec::Rake::SpecTask.new(:unit_tests) do |t|
   t.libs << 'lib'
   t.spec_opts = ['--color', '--format nested']
   t.spec_files = FileList['test/**/*.rb']
-  t.spec_files.delete_if {|x| x =~ /.*factories.rb/ || x =~ /.*spec_helper.rb/ || x =~ /.*integration.*/}
+  t.spec_files.delete_if  do |x|
+    (x =~ /.*factories.rb/) ||
+    (x =~ /.*spec_helper.rb/) ||
+      (x =~ /.*preinclude_tests.rb/) ||
+      (x =~ /.*integration.*/)
+  end
   t.spec_files.unshift("test/aws/factories.rb")
   t.spec_files.unshift("test/aws/spec_helper.rb")
+  t.spec_files.unshift("test/aws/preinclude_tests.rb")
 end
 task :test => :unit_tests
 
@@ -32,8 +38,13 @@ Spec::Rake::SpecTask.new do |t|
   #t.ruby_opts = ['-rspec/test/unit'] # Add this line in if you're using Test::Unit instead of RSpec
   t.spec_opts = ['--color', '--format nested']
   t.spec_files = FileList['test/**/*.rb']
-  t.spec_files.delete_if {|x| x =~ /.*factories.rb/ || x =~ /.*spec_helper.rb/}
+  t.spec_files.delete_if  do |x|
+    (x =~ /.*factories.rb/) ||
+    (x =~ /.*spec_helper.rb/) ||
+      (x =~ /.*preinclude_tests.rb/)
+  end
   t.spec_files.unshift("test/aws/factories.rb")
   t.spec_files.unshift("test/aws/spec_helper.rb")
+  t.spec_files.unshift("test/aws/preinclude_tests.rb")
 end
 task :integration_tests => :spec

data/lib/aws/decider/activity.rb

@@ -170,8 +170,11 @@ module AWS
         activity_id = @decision_helper.get_activity_id(attributes[:scheduled_event_id])
         @decision_helper[activity_id].consume(:handle_completion_event)
         open_request_info = @decision_helper.scheduled_activities.delete(activity_id)
-        reason = attributes[:reason]
-        details = attributes[:details]
+        reason = attributes[:reason] if attributes.keys.include? :reason
+        reason ||= "The activity which failed did not provide a reason"
+        details = attributes[:details] if attributes.keys.include? :details
+        details ||= "The activity which failed did not provide details"
+
         # TODO consider adding user_context to open request, and adding it here
         # @decision_helper[@decision_helper.activity_scheduling_event_id_to_activity_id[event.attributes.scheduled_event_id]].attributes[:options].data_converter
         failure = ActivityTaskFailedException.new(event.id, activity_id, reason, details)

data/lib/aws/decider/async_retrying_executor.rb

@@ -25,28 +25,42 @@ module AWS
       end
       def execute(command, options = nil)
         return schedule_with_retry(command, nil, Hash.new { |hash, key| hash[key] = 1 }, @clock.current_time, 0) if @return_on_start
-        task do
-          schedule_with_retry(command, nil, Hash.new { |hash, key| hash[key] = 1 }, @clock.current_time, 0)
+        output = Utilities::AddressableFuture.new
+        result_lock = Utilities::AddressableFuture.new
+        error_handler do |t|
+          t.begin do
+            output.set(schedule_with_retry(command, nil, Hash.new { |hash, key| hash[key] = 1 }, @clock.current_time, 0))
+          end
+          t.rescue(Exception) do |error|
+            @error_seen = error
+          end
+          t.ensure do
+            output.set unless output.set?
+            result_lock.set
+          end
         end
+        result_lock.get
+        raise @error_seen if @error_seen
+        output
       end
 
-      def schedule_with_retry(command, failure, attempt, first_attempt_time, time_of_recorded_failure)
+      def schedule_with_retry(command, failure, attempts, first_attempt_time, time_of_recorded_failure)
         delay = -1
-        if attempt.values.reduce(0, :+) > 1
+        if attempts.values.reduce(0, :+) > 1
           raise failure unless @retrying_policy.isRetryable(failure)
-          delay = @retrying_policy.next_retry_delay_seconds(first_attempt_time, time_of_recorded_failure, attempt, failure, @execution_id)
+          delay = @retrying_policy.next_retry_delay_seconds(first_attempt_time, time_of_recorded_failure, attempts, failure, @execution_id)
           raise failure if delay < 0
         end
         if delay > 0
           task do
-            @clock.create_timer(delay, lambda { invoke(command, attempt, first_attempt_time) })
+            @clock.create_timer(delay, lambda { invoke(command, attempts, first_attempt_time) })
           end
         else
-          invoke(command, attempt, first_attempt_time)
+          invoke(command, attempts, first_attempt_time)
         end
       end
 
-      def invoke(command, attempt, first_attempt_time)
+      def invoke(command, attempts, first_attempt_time)
         failure_to_retry = nil
         should_retry = Future.new
         return_value = Future.new
@@ -62,8 +76,8 @@ module AWS
         task do
           failure = should_retry.get
           if ! failure.nil?
-            attempt[failure.class] += 1
-            output.set(schedule_with_retry(command, failure, attempt, first_attempt_time, @clock.current_time - first_attempt_time))
+            attempts[failure.class] += 1
+            output.set(schedule_with_retry(command, failure, attempts, first_attempt_time, @clock.current_time - first_attempt_time))
           else
             output.set(return_value.get)
           end
@@ -94,6 +108,7 @@ module AWS
         @retries_per_exception = options.retries_per_exception
         @should_jitter = options.should_jitter
         @jitter_function = options.jitter_function
+        @options = options
       end
 
       # @param failure
@@ -125,29 +140,40 @@ module AWS
       #
       # @param time_of_recorded_failure
       #
-      # @param attempt
+      # @param attempts
       #
       # @param failure
       #
-      def next_retry_delay_seconds(first_attempt, time_of_recorded_failure, attempt, failure = nil, execution_id)
-        if attempt.values.reduce(0, :+) < 2
-          raise "This is bad, you have less than 2 attempts. More precisely, #{attempt} attempts"
+      def next_retry_delay_seconds(first_attempt, time_of_recorded_failure, attempts, failure = nil, execution_id)
+        if attempts.values.reduce(0, :+) < 2
+          raise "This is bad, you have less than 2 attempts. More precisely, #{attempts} attempts"
         end
         if @max_attempts && @max_attempts != "NONE"
-          return -1 if attempt.values.reduce(0, :+) > @max_attempts + 1
+          return -1 if attempts.values.reduce(0, :+) > @max_attempts + 1
         end
         if failure && @retries_per_exception && @retries_per_exception.keys.include?(failure.class)
-          return -1 if attempt[failure.class] > @retries_per_exception[failure.class]
+          return -1 if attempts[failure.class] > @retries_per_exception[failure.class]
         end
         return -1 if failure == nil
 
-        # Check to see if we should jitter or not and pass in the jitter function to retry function accordingly.
-        retry_seconds = @retry_function.call(first_attempt, time_of_recorded_failure, attempt)
+
+        # For reverse compatbility purposes, we must ensure that this function
+        # can take 3 arguments. However, we must also consume options in order
+        # for the default retry function to work correctly. Because we support
+        # ruby 1.9, we cannot use default arguments in a lambda, so we resort to
+        # the following workaround to supply a 4th argument if the function
+        # expects it.
+        call_args = [first_attempt, time_of_recorded_failure, attempts]
+        call_args << @options if @retry_function.arity == 4
+        retry_seconds = @retry_function.call(*call_args)
+        # Check to see if we should jitter or not and pass in the jitter
+        # function to retry function accordingly.
         if @should_jitter
            retry_seconds += @jitter_function.call(execution_id, retry_seconds/2)
         end
         return retry_seconds
       end
     end
+
   end
 end

data/lib/aws/decider/decider.rb

@@ -111,8 +111,11 @@ module AWS
                        :consume_symbol => :handle_completion_event,
                        :decision_helper_scheduled => :scheduled_external_workflows,
                        :handle_open_request => lambda do |event, open_request|
-                         reason = event.attributes.reason
-                         details = event.attributes.details
+                         attributes = event.attributes
+                         reason = attributes[:reason] if attributes.keys.include? :reason
+                         reason ||= "The activity which failed did not provide a reason"
+                         details = attributes[:details] if attributes.keys.include? :details
+                         details ||= "The activity which failed did not provide details"
                          # workflow_id = @decision_helper.child_initiated_event_id_to_workflow_id[event.attributes.initiated_event_id]
                          # @decision_helper.scheduled_external_workflows[workflow_id]
                          failure = ChildWorkflowFailedException.new(event.id, event.attributes[:workflow_execution], event.attributes.workflow_type, reason, details )
@@ -202,7 +205,7 @@ module AWS
                      })
       end
 
-      # Handler for the StartExternalWorkflowExecutionFailed event.
+      # Handler for the StartChildWorkflowExecutionFailed event.
       #
       # @param [Object] event The event instance.
       #
@@ -212,7 +215,7 @@ module AWS
                      :consume_symbol => :handle_initiation_failed_event,
                      :decision_helper_scheduled => :scheduled_external_workflows,
                      :handle_open_request => lambda do |event, open_request|
-                       workflow_execution = AWS::SimpleWorkflow::WorkflowExecution.new("",event.attributes.workflow_id, event.attributes.run_id)
+                         workflow_execution = AWS::SimpleWorkflow::WorkflowExecution.new("",event.attributes.workflow_id, nil)
                        workflow_type = event.attributes.workflow_type
                        cause = event.attributes.cause
                        failure = StartChildWorkflowFailedException.new(event.id, workflow_execution, workflow_type, cause)

data/lib/aws/decider/exceptions.rb

@@ -17,7 +17,7 @@ module AWS
   module Flow
 
 
-        # Exception used to communicate failure during fulfillment of a decision sent to SWF. This exception and all its
+    # Exception used to communicate failure during fulfillment of a decision sent to SWF. This exception and all its
     # subclasses are expected to be thrown by the framework.
     class DecisionException < Exception
       attr_accessor :event_id

data/lib/aws/decider/executor.rb

@@ -91,11 +91,19 @@ module AWS
         unless @pids.empty?
           @log.info "Exit requested, waiting up to #{timeout_seconds} seconds for child processes to finish"
 
-          # check every second for child processes to finish
-          timeout_seconds.times do
-            sleep 1
-            remove_completed_pids
-            break if @pids.empty?
+          # If the timeout_seconds value is set to Float::INFINITY, it will wait indefinitely till all workers finish
+          # their work. This allows us to handle graceful shutdown of workers.
+          if timeout_seconds == Float::INFINITY
+            @log.info "Exit requested, waiting indefinitely till all child processes finish"
+            remove_completed_pids true while !@pids.empty?
+          else
+            @log.info "Exit requested, waiting up to #{timeout_seconds} seconds for child processes to finish"
+            # check every second for child processes to finish
+            timeout_seconds.times do
+              sleep 1
+              remove_completed_pids
+              break if @pids.empty?
+            end
           end
 
           # forcibly kill all remaining children

data/lib/aws/decider/flow_defaults.rb

@@ -17,7 +17,7 @@ module AWS
   module Flow
     class FlowConstants
       class << self
-        attr_reader :exponential_retry_maximum_retry_interval_seconds, :exponential_retry_retry_expiration_seconds, :exponential_retry_backoff_coefficient, :exponential_retry_maximum_attempts, :exponential_retry_function, :default_data_converter, :exponential_retry_exceptions_to_include, :exponential_retry_exceptions_to_exclude, :jitter_function, :should_jitter
+        attr_reader :exponential_retry_maximum_retry_interval_seconds, :exponential_retry_retry_expiration_seconds, :exponential_retry_backoff_coefficient, :exponential_retry_maximum_attempts, :exponential_retry_function, :default_data_converter, :exponential_retry_exceptions_to_include, :exponential_retry_exceptions_to_exclude, :jitter_function, :should_jitter, :exponential_retry_initial_retry_interval
         # # The maximum exponential retry interval, in seconds. Use the value -1 (the default) to set <i>no maximum</i>.
         # attr_reader :exponential_retry_maximum_retry_interval_seconds
 
@@ -48,14 +48,24 @@ module AWS
       @should_jitter = true
       @exponential_retry_exceptions_to_exclude = []
       @exponential_retry_exceptions_to_include = [Exception]
-      @exponential_retry_function = lambda do |first, time_of_failure, attempts|
+      @exponential_retry_function = lambda do |first, time_of_failure, attempts, options|
+
         raise ArgumentError.new("first is not an instance of Time") unless first.instance_of?(Time)
         raise ArgumentError.new("time_of_failure can't be negative") if time_of_failure < 0
         raise ArgumentError.new("number of attempts can't be negative") if (attempts.values.find {|x| x < 0})
-        result = @exponential_retry_initial_retry_interval * (@exponential_retry_backoff_coefficient ** (attempts.values.reduce(0, :+) - 2))
-        result = @exponential_retry_maximum_retry_interval_seconds if @exponential_retry_maximum_retry_interval_seconds != INFINITY && result > @exponential_retry_maximum_retry_interval_seconds
+        raise ArgumentError.new("number of attempts should be more than 2") if (attempts.values.reduce(0,:+) < 2)
+        raise ArgumentError.new("user options must be of type ExponentialRetryOptions") unless options.is_a? ExponentialRetryOptions
+
+        initial_retry_interval = options.initial_retry_interval
+        backoff_coefficient = options.backoff_coefficient
+        maximum_retry_interval_seconds = options.maximum_retry_interval_seconds
+        retry_expiration_interval_seconds = options.retry_expiration_interval_seconds
+        result = initial_retry_interval * (backoff_coefficient ** (attempts.values.reduce(0, :+) - 2))
+        result = maximum_retry_interval_seconds if (! maximum_retry_interval_seconds.nil? && maximum_retry_interval_seconds != INFINITY && result > maximum_retry_interval_seconds)
         seconds_since_first_attempt = time_of_failure.zero? ? 0 : -(first - time_of_failure).to_i
-        result = -1 if @exponential_retry_retry_expiration_seconds != INFINITY && (result + seconds_since_first_attempt) >= @exponential_retry_retry_expiration_seconds
+        result = -1 if (! retry_expiration_interval_seconds.nil? &&
+                        retry_expiration_interval_seconds != INFINITY &&
+                        (result + seconds_since_first_attempt) >= retry_expiration_interval_seconds)
         return result.to_i
       end
 

data/lib/aws/decider/generic_client.rb

@@ -139,7 +139,7 @@ module AWS
       # @!visibility private
       def _retry(method_name, retry_function, block, args = NoInput.new)
         bail_if_external
-        retry_options = Utilities::interpret_block_for_options(RetryOptions, block)
+        retry_options = Utilities::interpret_block_for_options(ExponentialRetryOptions, block)
         _retry_with_options(lambda { self.send(method_name, *args) }, retry_function, retry_options)
       end
 

data/lib/aws/decider/implementation.rb

@@ -41,6 +41,7 @@ module AWS
       AWS::Flow.send(:workflow_client, service, domain, &block)
     end
 
+
     # Execute a block with retries within a workflow context.
     #
     # @param options
@@ -50,14 +51,22 @@ module AWS
     #   The block to execute.
     #
     def with_retry(options = {}, &block)
+      # TODO raise a specific error instead of a runtime error
       raise "with_retry can only be used inside a workflow context!" if Utilities::is_external
-      retry_options = RetryOptions.new(options)
+      retry_options = ExponentialRetryOptions.new(options)
       retry_policy = RetryPolicy.new(retry_options.retry_function, retry_options)
       async_retrying_executor = AsyncRetryingExecutor.new(retry_policy, self.decision_context.workflow_clock, retry_options.return_on_start)
       future = async_retrying_executor.execute(lambda { block.call })
       Utilities::drill_on_future(future) unless retry_options.return_on_start
     end
 
+    def decision_context
+      FlowFiber.current[:decision_context]
+    end
+
+    module_function :decision_context
+
+    module_function :with_retry
 
     # @!visibility private
     def self.workflow_client(service = nil, domain = nil, &block)

data/lib/aws/decider/options.rb

@@ -156,13 +156,16 @@ module AWS
       def retry_function; FlowConstants.exponential_retry_function; end
       def exceptions_to_include; FlowConstants.exponential_retry_exceptions_to_include; end
       def exceptions_to_exclude; FlowConstants.exponential_retry_exceptions_to_exclude; end
+      def backoff_coefficient; FlowConstants.exponential_retry_backoff_coefficient; end
       def should_jitter; FlowConstants.should_jitter; end
       def jitter_function; FlowConstants.jitter_function; end
+      def initial_retry_interval; FlowConstants.exponential_retry_initial_retry_interval; end
     end
 
     # Retry options used with {GenericClient#retry} and {ActivityClient#exponential_retry}
     class RetryOptions < Options
       property(:is_retryable_function, [])
+      property(:initial_retry_interval, [])
       property(:exceptions_to_allow, [])
       property(:maximum_attempts, [lambda {|x| x == "NONE" ? "NONE" : x.to_i}])
       property(:maximum_retry_interval_seconds, [lambda {|x| x == "NONE" ? "NONE" : x.to_i}])
@@ -238,13 +241,14 @@ module AWS
       # The backoff coefficient to use. This is a floating point value that is multiplied with the current retry
       # interval after every retry attempt. The default value is 2.0, which means that each retry will take twice as
       # long as the previous.
-      attr_accessor :backoff_coefficient
+      default_classes << RetryDefaults.new
+      property(:backoff_coefficient, [lambda(&:to_i)])
 
       # The retry expiration interval, in seconds. This will be increased after every retry attempt by the factor
       # provided in +backoff_coefficient+.
-      attr_accessor :retry_expiration_interval_seconds
+      property(:retry_expiration_interval_seconds, [lambda(&:to_i)])
 
-      def next_retry_delay_seconds(first_attmept, recorded_failure, attempts)
+      def next_retry_delay_seconds(first_attempt, recorded_failure, attempts)
         raise IllegalArgumentException "Attempt number is #{attempts}, when it needs to be greater than 1"
         if @maximum_attempts
         end

data/lib/aws/decider/state_machines.rb

@@ -139,10 +139,10 @@ module AWS
        [:created, :handle_decision_task_started_event, :decision_sent],
        [:decision_sent, :cancel, :cancelled_before_initiated],
        [:decision_sent, :handle_initiated_event, :initiated],
-       [:decision_sent, :handle_initiation_failed_event, :decision_sent],
+       [:decision_sent, :handle_initiation_failed_event, :completed],
        [:initiated, :cancel, :cancelled_after_initiated],
-                       [:initiated, :handle_completion_event, :completed],
-                       [:started, :handle_decision_task_started_event, :started],
+       [:initiated, :handle_completion_event, :completed],
+       [:started, :handle_decision_task_started_event, :started],
                       ]
       self_transitions(:handle_decision_task_started_event)
 

data/lib/aws/decider/task_poller.rb

@@ -80,16 +80,14 @@ module AWS
     end
 
     class ActivityTaskPoller
-      def initialize(service, domain, task_list, activity_definition_map, options=nil)
+      def initialize(service, domain, task_list, activity_definition_map, executor, options=nil)
         @service = service
         @domain = domain
         @task_list = task_list
         @activity_definition_map = activity_definition_map
         @logger = options.logger if options
         @logger ||= Utilities::LogFactory.make_logger(self, "debug")
-        max_workers = options.execution_workers if options
-        max_workers = 20 if (max_workers.nil? || max_workers.zero?)
-        @executor = ForkingExecutor.new(:max_workers => max_workers, :logger => @logger)
+        @executor = executor
 
       end
 

data/lib/aws/decider/version.rb

@@ -16,7 +16,7 @@
 module AWS
   module Flow
     def self.version
-      "1.0.4"
+      "1.0.5"
     end
   end
 end

data/lib/aws/decider/worker.rb

@@ -230,7 +230,27 @@ module AWS
         @activity_definition_map = {}
         @activity_type_options = []
         @options = Utilities::interpret_block_for_options(WorkerOptions, block)
+        @logger = @options.logger if @options
+        @logger ||= Utilities::LogFactory.make_logger(self, "debug")
+        max_workers = @options.execution_workers if @options
+        max_workers = 20 if (max_workers.nil? || max_workers.zero?)
+        @executor = ForkingExecutor.new(:max_workers => max_workers, :logger => @logger)
         super(service, domain, task_list, *args)
+
+        @shutting_down = false
+        %w{ TERM INT }.each do |signal|
+          Signal.trap(signal) do
+            if @shutting_down
+              @executor.shutdown 0
+              Kernel.exit! 1
+            else
+              @shutting_down = true
+              @executor.shutdown Float::INFINITY
+              Kernel.exit
+            end
+          end
+        end
+
       end
 
       # Adds an Activity implementation to this ActivityWorker.
@@ -297,7 +317,7 @@ module AWS
       #
       def start(should_register = true)
         register if should_register
-        poller = ActivityTaskPoller.new(@service, @domain, @task_list, @activity_definition_map, @options)
+        poller = ActivityTaskPoller.new(@service, @domain, @task_list, @activity_definition_map, @executor, @options)
         loop do
           run_once(false, poller)
         end
@@ -313,7 +333,7 @@ module AWS
       #
       def run_once(should_register = true, poller = nil)
         register if should_register
-        poller = ActivityTaskPoller.new(@service, @domain, @task_list, @activity_definition_map, @options) if poller.nil?
+        poller = ActivityTaskPoller.new(@service, @domain, @task_list, @activity_definition_map, @executor, @options) if poller.nil?
         poller.poll_and_process_single_task(@options.use_forking)
       end
     end

data/lib/aws/decider/workflow_definition.rb

@@ -82,6 +82,7 @@ module AWS
         converter = method_pair.data_converter
         method_name = method_pair.method_name
         error_handler do |t|
+          parameters = nil
           t.begin do
             if input.class <= NoInput
               @instance.send(method_name)

data/test/aws/decider_spec.rb

@@ -389,6 +389,17 @@ describe "FakeHistory" do
         @trace ||= []
         @trace << task_completed_request
       end
+      def start_workflow_execution(options)
+        @trace ||= []
+        @trace << options
+        {"runId" => "blah"}
+      end
+      def register_activity_type(options)
+      end
+      def register_workflow_type(options)
+      end
+      def respond_activity_task_completed(task_token, result)
+      end
       def start_workflow_execution(options)
         {"runId" => "blah"}
       end
@@ -1174,8 +1185,8 @@ describe "FakeHistory" do
     worker.start
     swf_client.trace.first[:decisions].first[:start_timer_decision_attributes][:start_to_fire_timeout].should == "5"
   end
-
 end
+
 describe "Misc tests" do
   it "makes sure that Workflows is equivalent to Decider" do
     class TestDecider
@@ -1216,31 +1227,124 @@ describe "Misc tests" do
 end
 
 describe FlowConstants do
+  options = {
+    :initial_retry_interval => 1,
+    :backoff_coefficient => 2,
+    :should_jitter => false,
+    :maximum_retry_interval_seconds => 100
+  }
+  options = ExponentialRetryOptions.new(options)
 
   it "will test the default retry function with regular cases" do
     test_first = [Time.now, Time.now, Time.now]
     test_time_of_failure = [0, 10, 100]
-    test_attempts = [{}, {Exception=>1}, {ActivityTaskTimedOutException=>5, Exception=>2}]
-    test_output = [0, 1, 64]
+    test_attempts = [{Exception=>2}, {Exception=>4}, {ActivityTaskTimedOutException=>5, Exception=>2}]
+    test_output = [1, 4, 32]
     arr = test_first.zip(test_time_of_failure, test_attempts, test_output)
     arr.each do |first, time_of_failure, attempts, output|
-      result = FlowConstants.exponential_retry_function.call(first, time_of_failure, attempts)
+      result = FlowConstants.exponential_retry_function.call(first, time_of_failure, attempts, options)
       (result == output).should == true
     end
   end
 
   it "will test for exceptions" do
-    expect { FlowConstants.exponential_retry_function.call(-1, 1, {}) }.to raise_error(ArgumentError, "first is not an instance of Time")
-    expect { FlowConstants.exponential_retry_function.call(Time.now, -1, {}) }.to raise_error(ArgumentError, "time_of_failure can't be negative")
-    expect { FlowConstants.exponential_retry_function.call(Time.now, 1, {Exception=>-1}) }.to raise_error(ArgumentError, "number of attempts can't be negative")
-    expect { FlowConstants.exponential_retry_function.call(Time.now, 1, {Exception=>-1, ActivityTaskTimedOutException=>-10}) }.to raise_error(ArgumentError, "number of attempts can't be negative")
-    expect { FlowConstants.exponential_retry_function.call(Time.now, 1, {Exception=>2, ActivityTaskTimedOutException=>-10}) }.to raise_error(ArgumentError, "number of attempts can't be negative")
+    expect { FlowConstants.exponential_retry_function.call(-1, 1, {}, options) }.to raise_error(ArgumentError, "first is not an instance of Time")
+    expect { FlowConstants.exponential_retry_function.call(Time.now, -1, {}, options) }.to raise_error(ArgumentError, "time_of_failure can't be negative")
+    expect { FlowConstants.exponential_retry_function.call(Time.now, 1, {Exception=>-1}, options) }.to raise_error(ArgumentError, "number of attempts can't be negative")
+    expect { FlowConstants.exponential_retry_function.call(Time.now, 1, {Exception=>-1, ActivityTaskTimedOutException=>-10}, options) }.to raise_error(ArgumentError, "number of attempts can't be negative")
+    expect { FlowConstants.exponential_retry_function.call(Time.now, 1, {Exception=>2, ActivityTaskTimedOutException=>-10}, options) }.to raise_error(ArgumentError, "number of attempts can't be negative")
   end
 
 end
 
+class TestActivity
+  extend Activity
+
+  activity :run_activity1 do |o|
+    o.default_task_heartbeat_timeout = "3600"
+    o.default_task_list = "activity_task_list"
+    o.default_task_schedule_to_close_timeout = "3600"
+    o.default_task_schedule_to_start_timeout = "3600"
+    o.default_task_start_to_close_timeout = "3600"
+    o.version = "1"
+  end
+  def run_activity1
+    "first regular activity"
+  end
+  def run_activity2
+    "second regular activity"
+  end
+end
+
+class TestActivityWorker < ActivityWorker
+
+  attr_accessor :executor
+  def initialize(service, domain, task_list, forking_executor, *args, &block)
+    super(service, domain, task_list, *args)
+    @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
+  def dumb_fib(n)
+    n < 1 ? 1 : dumb_fib(n - 1) + dumb_fib(n - 2)
+  end
+
+  it "will test whether the ActivityWorker shuts down immediately if two or more interrupts are 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, 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
+    # Send 2 interrupts to the child process
+    2.times { Process.kill("INT", pid); sleep 3 }
+    status = Process.waitall
+    status[0][1].success?.should be_false
+  end
+
+end
 
 describe "testing changing default values in RetryOptions and RetryPolicy" do
 
@@ -1340,4 +1444,20 @@ describe "testing changing default values in RetryOptions and RetryPolicy" do
     result = retry_policy.next_retry_delay_seconds(Time.now, 0, {Exception=>4}, Exception.new, 1)
     result.should == 10
   end
+
+  it "makes sure that the default retry function will use the user provided options" do
+
+    first = Time.now
+    time_of_failure = 0
+    attempts = {Exception=>2}
+    options = {
+      :initial_retry_interval => 10,
+      :backoff_coefficient => 2,
+      :should_jitter => false,
+      :maximum_retry_interval_seconds => 5
+    }
+    options = ExponentialRetryOptions.new(options)
+    result = FlowConstants.exponential_retry_function.call(first, time_of_failure, attempts, options)
+    result.should == 5
+  end
 end

data/test/aws/integration_spec.rb

@@ -510,6 +510,78 @@ describe "RubyFlowDecider" do
     @my_workflow_client = workflow_client(@swf.client, @domain) { {:from_class => @workflow_class} }
   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
+
+    @activity_class.class_eval do
+      activity :run_activityManual do
+        {
+          :default_task_heartbeat_timeout => "3600",
+          :default_task_list => task_list,
+          :task_schedule_to_start_timeout => 120,
+          :task_start_to_close_timeout => 120,
+          :version => "1",
+          :manual_completion => true
+        }
+      end
+      def run_activityManual
+        $task_token = activity_execution_context.task_token
+      end
+    end
+
+    @workflow_class.class_eval do
+      def entry_point
+        begin
+          activity.run_activityManual
+        rescue Exception => e
+          #pass
+        end
+      end
+    end
+
+    activity_worker = ActivityWorker.new(@swf.client, @domain, "ActivityTaskFailedManually", @activity_class) {{ :use_forking => false }}
+    activity_worker.register
+
+    workflow_execution = @my_workflow_client.start_execution
+    @worker.run_once
+    activity_worker.run_once
+
+    $swf.client.respond_activity_task_failed(:task_token => $task_token)
+
+    @worker.run_once
+    workflow_execution.events.map(&:event_type).last.should == "WorkflowExecutionCompleted"
+  end
+
+  it "ensures that raising inside a with_retry propagates up correctly" do
+    general_test(:task_list => "WithRetryPropagation", :class_name => "WithRetryPropagation")
+    @workflow_class.class_eval do
+      def entry_point
+        error = nil
+        begin
+          with_retry(:maximum_attempts => 1) { activity.run_activity1 }
+        rescue ActivityTaskFailedException => e
+          error = e
+        end
+        return error
+      end
+    end
+    @activity_class.class_eval do
+      def run_activity1
+        raise "Error!"
+      end
+    end
+    workflow_execution = @my_workflow_client.start_execution
+    @worker.run_once
+    @activity_worker.run_once
+    @worker.run_once
+    @worker.run_once
+    @activity_worker.run_once
+    @worker.run_once
+    workflow_execution.events.map(&:event_type).last.should == "WorkflowExecutionCompleted"
+    workflow_execution.events.to_a[-1].attributes.result.should =~ /Error!/
+  end
+
   it "ensures that backtraces are set correctly with yaml" do
     general_test(:task_list => "Backtrace_test", :class_name => "BacktraceTest")
     @workflow_class.class_eval do
@@ -538,114 +610,144 @@ describe "RubyFlowDecider" do
     # This also effectively tests "RequestCancelExternalWorkflowExecutionInitiated"
 
     # TODO: These three tests will sometimes fail, seemingly at random. We need to fix this.
-    # it "ensures that handle_child_workflow_execution_canceled is correct" do
-    #   class OtherCancellationChildWorkflow
-    #     extend Workflows
-    #     workflow(:entry_point) { {:version =>  1, :task_list => "new_child_workflow", :execution_start_to_close_timeout => 3600} }
-    #     def entry_point(arg)
-    #       create_timer(5)
-    #     end
-    #   end
-    #   class BadCancellationChildWorkflow
-    #     extend Workflows
-    #     workflow(:entry_point) { {:version =>  1, :task_list => "new_parent_workflow", :execution_start_to_close_timeout => 3600} }
-    #     def other_entry_point
-    #     end
+    it "ensures that handle_child_workflow_execution_canceled is correct" do
+      class OtherCancellationChildWorkflow
+        extend Workflows
+        workflow(:entry_point) { {:version =>  1, :task_list => "new_child_cancelled_workflow", :execution_start_to_close_timeout => 3600} }
+        def entry_point(arg)
+          create_timer(5)
+        end
+      end
+      class BadCancellationChildWorkflow
+        extend Workflows
+        workflow(:entry_point) { {:version =>  1, :task_list => "new_parent_cancelled_workflow", :execution_start_to_close_timeout => 3600} }
 
-    #     def entry_point(arg)
-    #       client = workflow_client($swf.client, $domain) { {:from_class => "OtherCancellationChildWorkflow"} }
-    #       workflow_future = client.send_async(:start_execution, 5)
-    #       client.request_cancel_workflow_execution(workflow_future)
-    #     end
-    #   end
-    #   worker2 = WorkflowWorker.new(@swf.client, @domain, "new_child_workflow", OtherCancellationChildWorkflow)
-    #   worker2.register
-    #   worker = WorkflowWorker.new(@swf.client, @domain, "new_parent_workflow", BadCancellationChildWorkflow)
-    #   worker.register
-    #   client = workflow_client(@swf.client, @domain) { {:from_class => "BadCancellationChildWorkflow"} }
-    #   workflow_execution = client.entry_point(5)
-
-    #   worker.run_once
-    #   worker2.run_once
-    #   worker.run_once
-    #   workflow_execution.events.map(&:event_type).should include "ExternalWorkflowExecutionCancelRequested"
-    #   worker2.run_once
-    #   workflow_execution.events.map(&:event_type).should include "ChildWorkflowExecutionCanceled"
-    #   worker.run_once
-    #   workflow_execution.events.to_a.last.attributes.details.should =~ /AWS::Flow::Core::Cancellation/
-    # end
+        def entry_point(arg)
+          client = workflow_client($swf.client, $domain) { {:from_class => "OtherCancellationChildWorkflow"} }
+          workflow_future = client.send_async(:start_execution, 5)
+          client.request_cancel_workflow_execution(workflow_future)
+        end
+      end
+      worker2 = WorkflowWorker.new(@swf.client, @domain, "new_child_cancelled_workflow", OtherCancellationChildWorkflow)
+      worker2.register
+      worker = WorkflowWorker.new(@swf.client, @domain, "new_parent_cancelled_workflow", BadCancellationChildWorkflow)
+      worker.register
+      client = workflow_client(@swf.client, @domain) { {:from_class => "BadCancellationChildWorkflow"} }
+      workflow_execution = client.entry_point(5)
 
-    # it "ensures that handle_child_workflow_terminated is handled correctly" do
-    #   class OtherTerminationChildWorkflow
-    #     extend Workflows
-    #     workflow(:entry_point) { {:version =>  1, :task_list => "new_child_workflow", :execution_start_to_close_timeout => 3600} }
+      worker.run_once
+      worker2.run_once
+      worker.run_once
+      workflow_execution.events.map(&:event_type).should include "ExternalWorkflowExecutionCancelRequested"
+      worker2.run_once
+      workflow_execution.events.map(&:event_type).should include "ChildWorkflowExecutionCanceled"
+      worker.run_once
+      workflow_execution.events.to_a.last.attributes.details.should =~ /AWS::Flow::Core::Cancellation/
+    end
 
-    #     def entry_point(arg)
-    #       create_timer(5)
-    #     end
+    it "ensures that handle_child_workflow_terminated is handled correctly" do
+      class OtherTerminationChildWorkflow
+        extend Workflows
+        workflow(:entry_point) { {:version =>  1, :task_list => "new_child_terminated_workflow", :execution_start_to_close_timeout => 3600} }
 
-    #   end
-    #   $workflow_id = nil
-    #   class BadTerminationChildWorkflow
-    #     extend Workflows
-    #     workflow(:entry_point) { {:version =>  1, :task_list => "new_parent_workflow", :execution_start_to_close_timeout => 3600} }
-    #     def other_entry_point
-    #     end
+        def entry_point(arg)
+          create_timer(5)
+        end
 
-    #     def entry_point(arg)
-    #       client = workflow_client($swf.client, $domain) { {:from_class => "OtherTerminationChildWorkflow"} }
-    #       workflow_future = client.send_async(:start_execution, 5)
-    #       $workflow_id = workflow_future.workflow_execution.workflow_id.get
-    #     end
-    #   end
-    #   worker2 = WorkflowWorker.new(@swf.client, @domain, "new_child_workflow", OtherTerminationChildWorkflow)
-    #   worker2.register
-    #   worker = WorkflowWorker.new(@swf.client, @domain, "new_parent_workflow", BadTerminationChildWorkflow)
-    #   worker.register
-    #   client = workflow_client(@swf.client, @domain) { {:from_class => "BadTerminationChildWorkflow"} }
-    #   workflow_execution = client.entry_point(5)
-
-    #   worker.run_once
-    #   worker2.run_once
-    #   $swf.client.terminate_workflow_execution({:workflow_id => $workflow_id, :domain => $domain.name})
-    #   worker.run_once
-    #   workflow_execution.events.to_a.last.attributes.details.should =~ /AWS::Flow::ChildWorkflowTerminatedException/
-    # end
+      end
+      $workflow_id = nil
+      class BadTerminationChildWorkflow
+        extend Workflows
+        workflow(:entry_point) { {:version =>  1, :task_list => "new_parent_terminated_workflow", :execution_start_to_close_timeout => 3600} }
+        def other_entry_point
+        end
 
-    # it "ensures that handle_child_workflow_timed_out is handled correctly" do
-    #   class OtherTimedOutChildWorkflow
-    #     extend Workflows
-    #     workflow(:entry_point) { {:version =>  1, :task_list => "new_child_workflow", :execution_start_to_close_timeout => 5} }
+        def entry_point(arg)
+          client = workflow_client($swf.client, $domain) { {:from_class => "OtherTerminationChildWorkflow"} }
+          workflow_future = client.send_async(:start_execution, 5)
+          $workflow_id = workflow_future.workflow_execution.workflow_id.get
+        end
+      end
+      worker2 = WorkflowWorker.new(@swf.client, @domain, "new_child_terminated_workflow", OtherTerminationChildWorkflow)
+      worker2.register
+      worker = WorkflowWorker.new(@swf.client, @domain, "new_parent_terminated_workflow", BadTerminationChildWorkflow)
+      worker.register
+      client = workflow_client(@swf.client, @domain) { {:from_class => "BadTerminationChildWorkflow"} }
+      workflow_execution = client.entry_point(5)
 
-    #     def entry_point(arg)
-    #       create_timer(5)
-    #     end
+      worker.run_once
+      worker2.run_once
+      $swf.client.terminate_workflow_execution({:workflow_id => $workflow_id, :domain => $domain.name})
+      worker.run_once
+      workflow_execution.events.to_a.last.attributes.details.should =~ /AWS::Flow::ChildWorkflowTerminatedException/
+    end
 
-    #   end
-    #   $workflow_id = nil
-    #   class BadTimedOutChildWorkflow
-    #     extend Workflows
-    #     workflow(:entry_point) { {:version =>  1, :task_list => "new_parent_workflow", :execution_start_to_close_timeout => 3600} }
-    #     def other_entry_point
-    #     end
+    it "ensures that handle_child_workflow_timed_out is handled correctly" do
+      class OtherTimedOutChildWorkflow
+        extend Workflows
+        workflow(:entry_point) { {:version =>  1, :task_list => "new_child_timed_out_workflow", :execution_start_to_close_timeout => 5} }
 
-    #     def entry_point(arg)
-    #       client = workflow_client($swf.client, $domain) { {:from_class => "OtherTimedOutChildWorkflow"} }
-    #       workflow_future = client.send_async(:start_execution, 5)
-    #       $workflow_id = workflow_future.workflow_execution.workflow_id.get
-    #     end
-    #   end
-    #   worker2 = WorkflowWorker.new(@swf.client, @domain, "new_child_workflow", OtherTimedOutChildWorkflow)
-    #   worker2.register
-    #   worker = WorkflowWorker.new(@swf.client, @domain, "new_parent_workflow", BadTimedOutChildWorkflow)
-    #   worker.register
-    #   client = workflow_client(@swf.client, @domain) { {:from_class => "BadTimedOutChildWorkflow"} }
-    #   workflow_execution = client.entry_point(5)
-    #   worker.run_once
-    #   sleep 8
-    #   worker.run_once
-    #   workflow_execution.events.to_a.last.attributes.details.should =~ /AWS::Flow::ChildWorkflowTimedOutException/
-    # end
+        def entry_point(arg)
+          create_timer(5)
+        end
+
+      end
+      $workflow_id = nil
+      class BadTimedOutChildWorkflow
+        extend Workflows
+        workflow(:entry_point) { {:version =>  1, :task_list => "new_parent_timed_out_workflow", :execution_start_to_close_timeout => 3600} }
+        def other_entry_point
+        end
+
+        def entry_point(arg)
+          client = workflow_client($swf.client, $domain) { {:from_class => "OtherTimedOutChildWorkflow"} }
+          workflow_future = client.send_async(:start_execution, 5)
+          $workflow_id = workflow_future.workflow_execution.workflow_id.get
+        end
+      end
+      worker2 = WorkflowWorker.new(@swf.client, @domain, "new_child_timed_out_workflow", OtherTimedOutChildWorkflow)
+      worker2.register
+      worker = WorkflowWorker.new(@swf.client, @domain, "new_parent_timed_out_workflow", BadTimedOutChildWorkflow)
+      worker.register
+      client = workflow_client(@swf.client, @domain) { {:from_class => "BadTimedOutChildWorkflow"} }
+      workflow_execution = client.entry_point(5)
+      worker.run_once
+      sleep 8
+      worker.run_once
+      workflow_execution.events.to_a.last.attributes.details.should =~ /AWS::Flow::ChildWorkflowTimedOutException/
+    end
+
+    it "ensures that handle_start_child_workflow_execution_failed is fine" do
+      general_test(:task_list => "handle_start_child_workflow_execution_failed", :class_name => "HandleStartChildWorkflowExecutionFailed")
+      class FooBar
+        extend Workflows
+        workflow :bad_workflow do
+          {
+            :version => "1",
+            :execution_start_to_close_timeout => 3600,
+            :task_list => "handle_start_child_workflow_execution_failed_child"
+          }
+        end
+        def bad_workflow
+          raise "Child workflow died"
+        end
+      end
+      @workflow_class.class_eval do
+        def entry_point
+          wf = AWS::Flow.workflow_client { { :prefix_name => "FooBar", :execution_method => 'bad_workflow', :version => "1", :execution_start_to_close_timeout => 3600, :task_list => "handle_start_child_workflow_execution_failed_child" } }
+          wf.start_execution("foo")
+        end
+      end
+      workflow_execution = @my_workflow_client.start_execution
+      child_worker = WorkflowWorker.new($swf.client, $domain, "handle_start_child_workflow_execution_failed_child", FooBar)
+      child_worker.register
+      @worker.run_once
+      child_worker.run_once
+      @worker.run_once
+      workflow_execution.events.map(&:event_type).last.should == "WorkflowExecutionFailed"
+      # Make sure this is actually caused by a child workflow failed
+      workflow_execution.events.to_a.last.attributes.details.should =~ /ChildWorkflowFailed/
+    end
 
     it "ensures that handle_timer_canceled is fine" do
         general_test(:task_list => "handle_timer_canceled", :class_name => "HandleTimerCanceled")
@@ -1057,7 +1159,8 @@ describe "RubyFlowDecider" do
       worker.run_once
       activity_worker.run_once
       worker.run_once
-      workflow_execution.events.to_a[6].attributes[:result].should =~ /1/
+      activity_completed_index = workflow_execution.events.map(&:event_type).index("ActivityTaskCompleted")
+      workflow_execution.events.to_a[activity_completed_index].attributes.result.should =~ /1\z/
     end
 
     it "makes sure that timers work" do
@@ -1316,8 +1419,10 @@ describe "RubyFlowDecider" do
       worker.run_once
       worker2.run_once
       worker.run_once
+      # We have to find the index dynamically, because due to how scheduled/starts work, it isn't necessarily in the same place in our history.
+      child_execution_completed_index = workflow_execution.events.map(&:event_type).index("ChildWorkflowExecutionCompleted")
 
-      workflow_execution.events.to_a[7].attributes.result.should =~ /1/
+      workflow_execution.events.to_a[child_execution_completed_index].attributes.result.should =~ /1\z/
     end
 
     it "makes sure that the new way of doing child workflows works" do
@@ -2249,6 +2354,7 @@ describe "RubyFlowDecider" do
 
       worker.run_once
       internal_worker.run_once
+
       # Make sure that we finish the execution and fail before reporting ack
       sleep 10
       worker.run_once
@@ -2587,7 +2693,7 @@ describe "RubyFlowDecider" do
     execution.events.map(&:event_type).last.should == "WorkflowExecutionCompleted"
   end
 
-  it "makes sure that workers don't error out on schedule_activity_task_failed" do
+  it "makes sure that workflow errors out on schedule_activity_task_failed" do
     class BadActivityActivity
       extend Activity
       activity(:run_activity1) do
@@ -2608,7 +2714,7 @@ describe "RubyFlowDecider" do
     execution = client.with_opts(:task_list => "Foobarbaz").start_execution
     worker.run_once
     worker.run_once
-    execution.events.map(&:event_type).last.should == "DecisionTaskCompleted"
+    execution.events.map(&:event_type).last.should == "WorkflowExecutionFailed"
   end
 
   it "makes sure that you can have arbitrary activity names with from_class" do

data/test/aws/preinclude_tests.rb

@@ -0,0 +1,148 @@
+
+describe "will test a patch that makes sure with_retry and decision_context can be called without importing AWS::Flow module" do
+  before(:all) do
+    class FakeDomain
+      def initialize(workflow_type_object)
+        @workflow_type_object = workflow_type_object
+      end
+      def page; FakePage.new(@workflow_type_object); end
+      def workflow_executions; FakeWorkflowExecutionCollecton.new; end
+      def name; "fake_domain"; end
+    end
+
+    class FakeWorkflowExecutionCollecton
+      def at(workflow_id, run_id); "Workflow_execution"; end
+    end
+
+    # A fake service client used to mock out calls to the Simple Workflow Service
+    class FakeServiceClient
+      attr_accessor :trace
+      def respond_decision_task_completed(task_completed_request)
+        @trace ||= []
+        @trace << task_completed_request
+      end
+      def start_workflow_execution(options)
+        @trace ||= []
+        @trace << options
+        {"runId" => "blah"}
+      end
+      def register_workflow_type(options)
+      end
+    end
+
+    class SynchronousWorkflowWorker < AWS::Flow::WorkflowWorker
+      def start
+        poller = SynchronousWorkflowTaskPoller.new(@service, nil, AWS::Flow::DecisionTaskHandler.new(@workflow_definition_map), @task_list)
+        poller.poll_and_process_single_task
+      end
+    end
+
+    class FakeWorkflowType < AWS::Flow::WorkflowType
+      attr_accessor :domain, :name, :version
+      def initialize(domain, name, version)
+        @domain = domain
+        @name = name
+        @version = version
+      end
+    end
+
+    class TestHistoryWrapper
+      def initialize(workflow_type, events)
+        @workflow_type = workflow_type
+        @events = events
+      end
+      def workflow_execution
+        FakeWorkflowExecution.new
+      end
+      def task_token
+        "1"
+      end
+      def previous_started_event_id
+        1
+      end
+      attr_reader :events, :workflow_type
+    end
+
+    class FakeWorkflowExecution
+      def run_id
+        "1"
+      end
+    end
+
+    class TestHistoryEvent < AWS::SimpleWorkflow::HistoryEvent
+      def initialize(event_type, event_id, attributes)
+        @event_type = event_type
+        @attributes = attributes
+        @event_id = event_id
+        @created_at = Time.now
+      end
+    end
+
+    class SynchronousWorkflowTaskPoller < AWS::Flow::WorkflowTaskPoller
+      def get_decision_tasks
+        workflow_type = FakeWorkflowType.new(nil, "TestWorkflow.entry_point", "1")
+        TestHistoryWrapper.new(workflow_type,
+                               [TestHistoryEvent.new("WorkflowExecutionStarted", 1, {:parent_initiated_event_id=>0, :child_policy=>:request_cancel, :execution_start_to_close_timeout=>3600, :task_start_to_close_timeout=>5, :workflow_type=> workflow_type, :task_list=>"TestWorkflow_tasklist"}),
+                                TestHistoryEvent.new("DecisionTaskScheduled", 2, {:parent_initiated_event_id=>0, :child_policy=>:request_cancel, :execution_start_to_close_timeout=>3600, :task_start_to_close_timeout=>5, :workflow_type=> workflow_type, :task_list=>"TestWorkflow_tastlist"}),
+                                TestHistoryEvent.new("DecisionTaskStarted", 3, {:scheduled_event_id=>2, :identity=>"some_identity"}),
+        ])
+
+      end
+    end
+
+  end
+  it "makes sure that with_retry can be called without including AWS::Flow" do
+
+    class TestWorkflow
+      extend AWS::Flow::Workflows
+      workflow (:entry_point) { {:version => "1"} }
+
+      def entry_point
+        AWS::Flow::with_retry do
+          return "This is the entry point"
+        end
+      end
+    end
+
+    workflow_type_object = double("workflow_type", :name => "TestWorkflow.entry_point", :start_execution => "" )
+    domain = FakeDomain.new(workflow_type_object)
+    swf_client = FakeServiceClient.new
+    task_list = "TestWorkflow_tasklist"
+
+    workflow_worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list)
+    workflow_worker.add_workflow_implementation(TestWorkflow)
+
+    workflow_client = AWS::Flow::WorkflowClient.new(swf_client, domain, TestWorkflow, AWS::Flow::StartWorkflowOptions.new)
+    workflow_client.start_execution
+
+    workflow_worker.start
+  end
+
+  it "makes sure that decision_context can be called without including AWS::Flow" do
+
+    class TestWorkflow
+      extend AWS::Flow::Workflows
+      workflow (:entry_point) { {:version => "1"} }
+
+      def entry_point
+        return AWS::Flow::decision_context.workflow_clock.current_time
+      end
+    end
+
+    workflow_type_object = double("workflow_type", :name => "TestWorkflow.entry_point", :start_execution => "" )
+    domain = FakeDomain.new(workflow_type_object)
+    swf_client = FakeServiceClient.new
+    task_list = "TestWorkflow_tasklist"
+
+    workflow_worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list)
+    workflow_worker.add_workflow_implementation(TestWorkflow)
+
+    workflow_client = AWS::Flow::WorkflowClient.new(swf_client, domain, TestWorkflow, AWS::Flow::StartWorkflowOptions.new)
+    workflow_client.start_execution
+
+    workflow_worker.start
+  end
+
+end
+
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aws-flow
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-04 00:00:00.000000000 Z
+date: 2013-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -83,6 +83,7 @@ files:
 - test/aws/decider_spec.rb
 - test/aws/factories.rb
 - test/aws/integration_spec.rb
+- test/aws/preinclude_tests.rb
 - test/aws/spec_helper.rb
 homepage: 
 licenses: []