aws-flow 1.3.0 → 2.0.0

data/lib/aws/decider/state_machines.rb

@@ -334,6 +334,7 @@ module AWS
             :tag_list => @attributes[:tag_list]
           }
         }
+        result[:start_child_workflow_execution_decision_attributes].delete(:task_list) if options.task_list.nil?
         #TODO Figure out what control is
         to_add = options.get_options([:execution_start_to_close_timeout, :task_start_to_close_timeout, :child_policy, :tag_list, :input])
         result[attribute_name].merge!(to_add)

data/lib/aws/decider/utilities.rb

@@ -58,6 +58,21 @@ module AWS
         youngest.get_full_options
       end
 
+      # @api private
+      def self.client_options_from_method_name(method_name, options)
+        client_options = options.dup
+        if method_name.nil?
+          client_options.precursors = options.precursors.empty? ? [] : [options.precursors.first]
+        else
+          client_options.precursors = options.precursors.select { |x| x.name.split(".").last.to_sym == method_name }
+        end
+
+        unless options.precursors.empty?
+          client_options.precursors.map!(&:options)
+        end
+        client_options
+      end
+
 
       # @api private
       def self.interpret_block_for_options(option_class, block, use_defaults = false)

data/lib/aws/decider/version.rb

@@ -16,7 +16,7 @@
 module AWS
   module Flow
     def self.version
-      "1.3.0"
+      "2.0.0"
     end
   end
 end

data/lib/aws/decider/worker.rb

@@ -40,7 +40,6 @@ module AWS
         @service = service
         @domain = domain
         @task_list = task_list_to_poll
-        @options = Utilities::interpret_block_for_options(WorkerOptions, block)
         if args
           args.each { |klass_or_instance| add_implementation(klass_or_instance) }
         end
@@ -65,6 +64,10 @@ module AWS
           downcase
       end
 
+      def resolve_default_task_list(name)
+        name == FlowConstants.use_worker_task_list ? @task_list : name
+      end
+
     end
 
     module GenericTypeModule
@@ -137,7 +140,7 @@ module AWS
       end
 
       def set_workflow_implementation_types(workflow_implementation_types)
-        workflow_implementation_types.each {|type| add_workflow_implementation_type(type)}
+        workflow_implementation_types.each {|type| add_workflow_implementation(type)}
       end
 
       def add_implementation(workflow_class)
@@ -154,7 +157,7 @@ module AWS
           options = workflow_type.options
           execution_method = options.execution_method
           version = workflow_type.version
-          registration_options = nil
+          registration_options = options.get_registration_options
           implementation_options = nil
           get_state_method = workflow_class.get_state_method
           signals = workflow_class.signals
@@ -181,9 +184,10 @@ module AWS
               :version => version
             }
           )
+
           if options.default_task_list
             workflow_hash.merge!(
-              {:default_task_list => {:name => options.default_task_list} }
+              :default_task_list => {:name => resolve_default_task_list(options.default_task_list)}
             )
           end
           @workflow_type_options << workflow_hash
@@ -378,11 +382,13 @@ module AWS
             :version => activity_type.version
           }
 
-          option_hash.merge!(options.get_default_options)
+          option_hash.merge!(options.get_registration_options)
 
-          option_hash.merge!(
-            :default_task_list => {:name => options.default_task_list}
-          ) if options.default_task_list
+          if options.default_task_list
+            option_hash.merge!(
+              :default_task_list => {:name => resolve_default_task_list(options.default_task_list)}
+            )
+          end
 
           @activity_type_options << option_hash
         end

data/lib/aws/decider/workflow_client.rb

@@ -189,10 +189,14 @@ module AWS
       #   A hash of {StartWorkflowOptions} to use for this workflow execution.
       #
       def start_execution(*input, &block)
+        start_execution_method(nil, *input, &block)
+      end
+
+      def start_execution_method(method_name, *input, &block)
         if Utilities::is_external
-          self.start_external_workflow(input, &block)
+          self.start_external_workflow(method_name, input, &block)
         else
-          self.start_internal_workflow(input, &block)
+          self.start_internal_workflow(method_name, input, &block)
         end
       end
 
@@ -239,8 +243,6 @@ module AWS
         workflow_execution = workflow_execution.workflow_execution if workflow_execution.respond_to? :workflow_execution
         options.signal_name ||= signal_name.to_s
         options.workflow_id ||= workflow_execution.workflow_id.get.to_s
-        execution_method = options.execution_method || @options.execution_method
-        raise "You haven't specified an execution method!" if execution_method.nil?
         Utilities::merge_all_options(options)
         open_request = OpenRequestInfo.new
         decision_id = @decision_helper.get_next_id(:Signal)
@@ -264,13 +266,15 @@ module AWS
 
       # Called by {#start_execution}.
       # @api private
-      def start_internal_workflow(input = NoInput.new, &block)
+      def start_internal_workflow(method_name, input = NoInput.new, &block)
         get_decision_context
         options = Utilities::interpret_block_for_options(StartWorkflowOptions, block)
+        client_options = Utilities::client_options_from_method_name(method_name, @options)
+        options = Utilities::merge_all_options(client_options, options)
+
         workflow_id_future, run_id_future = Future.new, Future.new
         minimal_domain = MinimalDomain.new(@domain.name.to_s)
         output = WorkflowFuture.new(AWS::Flow::MinimalWorkflowExecution.new(minimal_domain, workflow_id_future, run_id_future))
-        options = Utilities::merge_all_options(@options, options)
         new_options = StartWorkflowOptions.new(options)
         open_request = OpenRequestInfo.new
         workflow_id = new_options.workflow_id
@@ -337,9 +341,11 @@ module AWS
 
       # Called by {#start_execution}.
       # @api private
-      def start_external_workflow(input = NoInput.new, &block)
+      def start_external_workflow(method_name, input = NoInput.new, &block)
         options = Utilities::interpret_block_for_options(StartWorkflowOptions, block)
-        options = Utilities::merge_all_options(@options, options)
+        client_options = Utilities::client_options_from_method_name(method_name, @options)
+        options = Utilities::merge_all_options(client_options, options)
+
         @converter ||= YAMLDataConverter.new
         # Basically, we want to avoid the special "NoInput, but allow stuff like nil in"
         if ! (input.class <= NoInput || input.empty?)
@@ -349,8 +355,7 @@ module AWS
           execution_method = @options.execution_method
           version = @options.version
         else
-          # TODO This is a nasty hack
-          workflow_type = @workflow_class.workflows.first
+          workflow_type = method_name.nil? ? @workflow_class.workflows.first : @workflow_class.workflows.select { |x| x.options.execution_method.to_sym == method_name }.first
           execution_method = workflow_type.options.execution_method
           version = workflow_type.version
         end
@@ -381,7 +386,7 @@ module AWS
 
       def method_missing(method_name, *args, &block)
         if is_execution_method(method_name)
-          start_execution(*args, &block)
+          start_execution_method(method_name, *args, &block)
         else
           super(method_name, *args, &block)
         end

data/lib/aws/runner.rb

@@ -17,17 +17,14 @@ module AWS
 
       # Example of the format:
       # {
-      #     "domains": [
-      #        {
-      #            "name": <name_of_the_domain>,
-      #            "retention_in_days": <days>
-      #        }
-      #         //, ... can add more
-      #     ],
+      #     "domain":
+      #     {
+      #        "name": <name_of_the_domain>,
+      #        "retention_in_days": <days>
+      #     }
       #     "activity_workers": [
       #         
       #        {
-      #             "domain": <name_of_the_domain>,
       #             "task_list": <name_of_the_task_list>,
       #             "activity_classes": [ <name_of_class_containing_the_activities_to_be_worked_on> ],
       #             "number_of_workers": <number_of_activity_workers_to_spawn>,
@@ -37,7 +34,6 @@ module AWS
       #     ],
       #     "workflow_workers": [
       #         {
-      #             "domain": <name_of_the_domain>,
       #             "task_list": <name_of_the_task_list>,
       #             "workflow_classes": [ <name_of_class_containing_the_workflows_to_be_worked_on> ],
       #             "number_of_workers": <number_of_workflow_workers_to_spawn>
@@ -56,19 +52,24 @@ module AWS
       # }
 
 
-      # registers the domains if they are not
-      def self.setup_domains(json_config)
+      # registers the domain if it is not
+      def self.setup_domain(json_config)
 
         swf = create_service_client(json_config)
 
-        json_config['domains'].each do |d|
-          begin
-            swf.client.describe_domain :name => d['name']
-          rescue
-            swf.client.register_domain( { :name => d['name'], 
-                                          :workflow_execution_retention_period_in_days => d['retention_in_days'].to_s })
-          end
+        domain = json_config['domain']
+        # If retention period is not provided, default it to 7 days
+        retention = domain['retention_in_days'] || FlowConstants::RETENTION_DEFAULT
+
+        begin
+          swf.client.register_domain({
+            name: domain['name'],
+            workflow_execution_retention_period_in_days: retention.to_s
+          })
+        rescue AWS::SimpleWorkflow::Errors::DomainAlreadyExistsFault => e
+          # possible log an INFO/WARN if the domain already exists.
         end
+        return AWS::SimpleWorkflow::Domain.new( domain['name'] )
       end
 
       def self.set_process_name(name)
@@ -106,7 +107,8 @@ module AWS
 
       def self.spawn_and_start_workers(json_fragment, process_name, worker)
         workers = []
-        json_fragment['number_of_workers'].times do
+        num_of_workers = json_fragment['number_of_workers'] || FlowConstants::NUM_OF_WORKERS_DEFAULT
+        num_of_workers.times do
           workers << fork do
             set_process_name(process_name)
             worker.start()
@@ -149,23 +151,25 @@ module AWS
         end
       end
 
-      def self.start_activity_workers(swf, config_path, json_config)
+      def self.start_activity_workers(swf, domain = nil, config_path, json_config)
         workers = []
         # load all classes for the activities
-        load_files(config_path, json_config, {:config_key => 'activity_paths',
-                     :default_file => File.join('flow', 'activities.rb')})
+        load_files(config_path, json_config, {config_key: 'activity_paths',
+                     default_file: File.join('flow', 'activities.rb')})
+        domain = setup_domain(json_config) if domain.nil?
 
         # TODO: logger
         # start the workers for each spec
         json_config['activity_workers'].each do |w|
-          fork_count = w['number_of_forks_per_worker'] || 1
-          domain = AWS::SimpleWorkflow::Domain.new( w['domain'] )
+          # If number of forks is not provided, it will automatically default to 20
+          # within the ActivityWorker
+          fork_count = w['number_of_forks_per_worker']
           task_list = expand_task_list(w['task_list'])
 
           # create a worker
-          worker = ActivityWorker.new(swf.client, domain, task_list, *w['activities']) {{ :max_workers => fork_count }}
-          add_implementations(worker, w, {:config_key => 'activity_classes',
-                     :clazz => AWS::Flow::Activities})
+          worker = ActivityWorker.new(swf.client, domain, task_list, *w['activities']) {{ max_workers: fork_count }}
+          add_implementations(worker, w, {config_key: 'activity_classes',
+                     clazz: AWS::Flow::Activities})
 
           # start as many workers as desired in child processes
           workers << spawn_and_start_workers(w, "activity-worker", worker)
@@ -174,22 +178,22 @@ module AWS
         return workers
       end
 
-      def self.start_workflow_workers(swf, config_path, json_config)
+      def self.start_workflow_workers(swf, domain = nil, config_path, json_config)
         workers = []
         # load all the classes for the workflows
-        load_files(config_path, json_config, {:config_key => 'workflow_paths',
-                     :default_file => File.join('flow', 'workflows.rb')})
+        load_files(config_path, json_config, {config_key: 'workflow_paths',
+                     default_file: File.join('flow', 'workflows.rb')})
+        domain = setup_domain(json_config) if domain.nil?
 
         # TODO: logger
         # start the workers for each spec
         json_config['workflow_workers'].each do |w|
-          domain = AWS::SimpleWorkflow::Domain.new( w['domain'] )
           task_list = expand_task_list(w['task_list'])
 
           # create a worker
           worker = WorkflowWorker.new(swf.client, domain, task_list, *w['workflows'])
-          add_implementations(worker, w, {:config_key => 'workflow_classes',
-                     :clazz => AWS::Flow::Workflows})
+          add_implementations(worker, w, {config_key: 'workflow_classes',
+                     clazz: AWS::Flow::Workflows})
 
           # start as many workers as desired in child processes
           workers << spawn_and_start_workers(w, "workflow-worker", worker)
@@ -201,7 +205,7 @@ module AWS
       def self.create_service_client(json_config)
         # set the UserAgent prefix for all clients
         if json_config['user_agent_prefix'] then
-          AWS.config(:user_agent_prefix => json_config['user_agent_prefix'])
+          AWS.config(user_agent_prefix: json_config['user_agent_prefix'])
         end
         
         swf = AWS::SimpleWorkflow.new
@@ -211,14 +215,14 @@ module AWS
       # this will start all the workers and return an array of pids for the worker
       # processes
       # 
-      def self.start_workers(config_path, json_config)
+      def self.start_workers(domain = nil, config_path, json_config)
         
         workers = []
         
         swf = create_service_client(json_config)
 
-        workers << start_activity_workers(swf, config_path, json_config)
-        workers << start_workflow_workers(swf, config_path, json_config)
+        workers << start_activity_workers(swf, domain, config_path, json_config)
+        workers << start_workflow_workers(swf, domain, config_path, json_config)
 
         # needed to avoid returning nested arrays based on the calls above
         workers.flatten!
@@ -279,8 +283,8 @@ module AWS
         config_path =  options[:file]
         config = load_config_json( config_path )
         add_dir_to_load_path( Pathname.new(config_path).dirname )
-        setup_domains(config)
-        workers = start_workers(config_path, config)
+        domain = setup_domain(config)
+        workers = start_workers(domain, config_path, config)
         setup_signal_handling(workers)
 
         # hang there until killed: this process is used to relay signals to children

data/spec/aws/decider/integration/activity_spec.rb

@@ -0,0 +1,345 @@
+require_relative 'setup'
+
+describe Activities do
+  before(:all) do
+    @swf, @domain = setup_swf
+  end
+
+  it "ensures that a real activity will get scheduled" do
+    task_list = "activity_task_list"
+    class Blah
+      extend AWS::Flow::Activities
+    end
+    class BasicActivity
+      extend AWS::Flow::Activities
+
+      activity :run_activity1 do
+        {
+          default_task_heartbeat_timeout: 60,
+          version: "1",
+          default_task_list: "activity_task_list",
+          default_task_schedule_to_close_timeout: 60,
+          default_task_schedule_to_start_timeout: 30,
+          default_task_start_to_close_timeout: 30,
+        }
+      end
+      def run_activity1; end
+    end
+    class BasicWorkflow
+      extend AWS::Flow::Workflows
+      workflow :start do
+        {
+          version: "1.0",
+          default_task_start_to_close_timeout: 30,
+          default_execution_start_to_close_timeout: 300,
+          default_child_policy: "REQUEST_CANCEL",
+          default_task_list: "activity_task_list"
+        }
+      end
+      activity_client(:activity) { { from_class: "BasicActivity" } }
+      def start
+        activity.run_activity1
+      end
+    end
+
+    worker = WorkflowWorker.new(@domain.client, @domain, task_list, BasicWorkflow)
+    activity_worker = ActivityWorker.new(@domain.client, @domain, task_list, BasicActivity)
+    workflow_type_name = "BasicWorkflow.start"
+    worker.register
+    activity_worker.register
+    workflow_type, _ = @domain.workflow_types.page(:per_page => 1000).select {|x| x.name == workflow_type_name}
+
+    workflow_execution = workflow_type.start_execution
+
+    worker.run_once
+    activity_worker.run_once
+    worker.run_once
+    wait_for_execution(workflow_execution)
+
+    workflow_execution.events.map(&:event_type).should ==
+      ["WorkflowExecutionStarted", "DecisionTaskScheduled", "DecisionTaskStarted", "DecisionTaskCompleted", "ActivityTaskScheduled", "ActivityTaskStarted", "ActivityTaskCompleted", "DecisionTaskScheduled", "DecisionTaskStarted", "DecisionTaskCompleted", "WorkflowExecutionCompleted"]
+  end
+
+  it "tests to see what two activities look like" do
+
+    class DoubleActivity
+      extend AWS::Flow::Activities
+      activity :run_activity1, :run_activity2 do
+        {
+          default_task_heartbeat_timeout: 60,
+          version: "1.0",
+          default_task_list: "double_activity_task_list",
+          default_task_schedule_to_close_timeout: 60,
+          default_task_schedule_to_start_timeout: 30,
+          default_task_start_to_close_timeout: 30,
+          exponential_retry: { 
+            retries_per_exception: { 
+              ActivityTaskTimedOutException: Float::INFINITY 
+            }
+          }
+        }
+      end
+      def run_activity1; end
+      def run_activity2; end
+    end
+
+    class DoubleWorkflow
+      extend AWS::Flow::Workflows
+      workflow(:start) do
+        {
+          version: "1.0",
+          default_task_start_to_close_timeout: 30,
+          default_execution_start_to_close_timeout: 300,
+          default_child_policy: "REQUEST_CANCEL",
+          default_task_list: "double_activity_task_list"
+        }
+      end
+      activity_client(:activity) { { from_class: "DoubleActivity" } }
+      def start
+        activity.send_async(:run_activity1)
+        activity.run_activity2
+      end
+    end
+
+    task_list = "double_activity_task_list"
+
+    worker = WorkflowWorker.new(@domain.client, @domain, task_list, DoubleWorkflow)
+    activity_worker = ActivityWorker.new(@domain.client, @domain, task_list, DoubleActivity)
+    workflow_type_name = "DoubleWorkflow.start"
+    worker.register
+    activity_worker.register
+    workflow_id = "basic_activity_workflow"
+
+    run_id = @swf.client.start_workflow_execution(
+      :workflow_type => {
+        :name => workflow_type_name,
+        :version => "1.0"
+      },
+      :workflow_id => workflow_id,
+      :domain => @domain.name.to_s
+    )
+    workflow_execution = AWS::SimpleWorkflow::WorkflowExecution.new(@domain, workflow_id, run_id["runId"])
+    @forking_executor = ForkingExecutor.new(:max_workers => 3)
+    @forking_executor.execute { worker.start }
+    @forking_executor.execute { activity_worker.start }
+    wait_for_execution(workflow_execution)
+
+    workflow_history = workflow_execution.events.map(&:event_type)
+    workflow_history.count("ActivityTaskCompleted").should == 2
+    workflow_history.count("WorkflowExecutionCompleted").should == 1
+  end
+
+  it "tests to see that two subsequent activities are supported" do
+    task_list = "subsequent_activity_task_list"
+    workflow_tasklist = "subsequent_workflow_task_list"
+    class SubsequentActivity
+      extend AWS::Flow::Activities
+
+      activity :run_activity1, :run_activity2 do
+        {
+          default_task_heartbeat_timeout: 300,
+          version: "1.2",
+          default_task_list: "subsequent_activity_task_list",
+          default_task_schedule_to_close_timeout: 60,
+          default_task_schedule_to_start_timeout: 30,
+          default_task_start_to_close_timeout: 30,
+        }
+      end
+      def run_activity1; end
+      def run_activity2; end
+    end
+    class SubsequentWorkflow
+      extend AWS::Flow::Workflows
+      workflow :start do
+        {
+          version: "1.2",
+          default_task_start_to_close_timeout: 30,
+          default_execution_start_to_close_timeout: 300,
+          default_child_policy: "REQUEST_CANCEL",
+          default_task_list: "subsequent_workflow_task_list"
+        }
+      end
+      activity_client(:activity) { { from_class: "SubsequentActivity" } }
+      def start
+        activity.run_activity1
+        activity.run_activity2
+      end
+    end
+
+    worker = WorkflowWorker.new(@domain.client, @domain, workflow_tasklist, SubsequentWorkflow)
+    activity_worker = ActivityWorker.new(@domain.client, @domain, task_list, SubsequentActivity)
+    worker.register
+    activity_worker.register
+
+    client = AWS::Flow::workflow_client(@domain.client, @domain) { { from_class: "SubsequentWorkflow" } }
+
+    workflow_execution = client.start_execution
+
+    @forking_executor = ForkingExecutor.new(:max_workers => 3)
+    @forking_executor.execute { worker.start }
+    @forking_executor.execute { activity_worker.start }
+
+    wait_for_execution(workflow_execution)
+    workflow_execution.events.map(&:event_type).count("WorkflowExecutionCompleted").should == 1
+  end
+
+  it "tests a much larger workflow" do
+    class LargeActivity
+      extend AWS::Flow::Activities
+
+      activity :run_activity1, :run_activity2, :run_activity3, :run_activity4 do
+        {
+          default_task_heartbeat_timeout: 60,
+          version: "1.0",
+          default_task_list: "large_activity_task_list",
+          default_task_schedule_to_close_timeout: 10,
+          default_task_schedule_to_start_timeout: 5,
+          default_task_start_to_close_timeout: 5,
+          exponential_retry: {
+            retries_per_exception: {
+              ActivityTaskTimedOutException => Float::INFINITY,
+            }
+          }
+        }
+    end
+      def run_activity1
+        "My name is Ozymandias - 1"
+      end
+      def run_activity2
+        "King of Kings! - 2 "
+      end
+      def run_activity3
+        "Look on my works, ye mighty - 3"
+      end
+      def run_activity4
+        "And Despair! - 4"
+      end
+    end
+
+    class LargeWorkflow
+      extend AWS::Flow::Workflows
+      workflow :start do
+        {
+          version: "1.0",
+          default_task_start_to_close_timeout: 30,
+          default_execution_start_to_close_timeout: 300,
+          default_child_policy: "REQUEST_CANCEL",
+          default_task_list: "large_activity_task_list"
+        }
+      end
+      activity_client(:activity) { { from_class: "LargeActivity" } }
+      def start
+        activity.send_async(:run_activity1)
+        activity.send_async(:run_activity2)
+        activity.send_async(:run_activity3)
+        activity.run_activity4
+      end
+    end
+
+    task_list = "large_activity_task_list"
+    worker = WorkflowWorker.new(@swf.client, @domain, task_list, LargeWorkflow)
+    activity_worker = ActivityWorker.new(@swf.client, @domain, task_list, LargeActivity)
+    worker.register
+    activity_worker.register
+
+    workflow_type_name = "LargeWorkflow.start"
+    workflow_type, _ = @domain.workflow_types.page(:per_page => 1000).select {|x| x.name == workflow_type_name}
+
+    workflow_execution = workflow_type.start_execution
+
+    @forking_executor = ForkingExecutor.new(:max_workers => 5)
+    @forking_executor.execute { activity_worker.start }
+
+    @forking_executor.execute { worker.start }
+
+    wait_for_execution(workflow_execution)
+
+    @forking_executor.shutdown(1)
+    workflow_history = workflow_execution.events.map(&:event_type)
+    workflow_history.count("WorkflowExecutionCompleted").should == 1
+    workflow_history.count("ActivityTaskCompleted").should == 4
+  end
+
+  context "Github issue 57" do
+
+    before(:all) do
+
+      class GithubIssue57TestActivity
+        extend AWS::Flow::Activities
+        activity :not_retryable do
+          {
+            version: 1.0,
+            default_task_list: "github_57_activity_tasklist",
+            default_task_schedule_to_start_timeout: 30,
+            default_task_start_to_close_timeout: 30,
+          }
+        end
+
+        activity :retryable do
+          {
+            version: 1.0,
+            default_task_list: "github_57_activity_tasklist",
+            default_task_schedule_to_start_timeout: 30,
+            default_task_start_to_close_timeout: 30,
+            exponential_retry: {
+              maximum_attempts: 3,
+            },
+          }
+        end
+
+        def not_retryable
+          raise 'blah'
+        end
+        def retryable
+          raise 'asdf'
+        end
+      end
+
+      class GithubIssue57TestWorkflow
+        extend AWS::Flow::Workflows
+
+        workflow :test do
+          {
+            version: 1.0,
+            default_task_list: "github_57_workflow_tasklist",
+            default_execution_start_to_close_timeout: 300,
+            default_task_start_to_close_timeout: 30
+          }
+        end
+
+        activity_client(:client) { { from_class: "GithubIssue57TestActivity" } }
+
+        def test
+          client.not_retryable
+        end
+      end
+    end
+
+
+    it "ensures _options method returns an array of type ActivityType" do
+      GithubIssue57TestActivity._options.size == 2
+      GithubIssue57TestActivity._options.each { |x| x.should be_an ActivityType }
+    end
+
+    it "ensures the activity gets set with the right options" do
+      worker = WorkflowWorker.new(@domain.client, @domain, "github_57_workflow_tasklist", GithubIssue57TestWorkflow)
+      activity_worker = ActivityWorker.new(@domain.client, @domain, "github_57_activity_tasklist", GithubIssue57TestActivity)
+      worker.register
+      activity_worker.register
+      client = workflow_client(@domain.client, @domain) { { from_class: GithubIssue57TestWorkflow } }
+
+      workflow_execution = client.start_execution
+
+      @forking_executor = ForkingExecutor.new(:max_workers => 3)
+      @forking_executor.execute { worker.start }
+      @forking_executor.execute { activity_worker.start }
+
+      wait_for_execution(workflow_execution)
+
+      history_events = workflow_execution.events.map(&:event_type)
+      history_events.last.should == "WorkflowExecutionFailed"
+      history_events.count("ActivityTaskFailed").should == 1
+    end
+  end
+end
+