aws-flow 2.3.1 → 2.4.0

data/spec/aws/decider/unit/options_spec.rb

@@ -47,11 +47,11 @@ describe AWS::Flow::ActivityRegistrationOptions do
         default_task_start_to_close_timeout: "NONE",
         default_task_priority: "0",
         default_task_list: "USE_WORKER_TASK_LIST",
-        data_converter: FlowConstants.default_data_converter
+        data_converter: FlowConstants.data_converter
       }
       # We first compare and remove the following values because these objects have issues
       # when we sort the values array below
-      full_options.delete(:data_converter) == expected.delete(:data_converter)
+      full_options.delete(:data_converter).should be_kind_of(expected.delete(:data_converter).class)
       full_options.keys.sort.should == expected.keys.sort
       full_options.values.sort.should == expected.values.sort
     end
@@ -82,11 +82,12 @@ describe AWS::Flow::ActivityRegistrationOptions do
         prefix_name: "FooActivity",
         manual_completion: true,
         heartbeat_timeout: "10",
-        data_converter: FlowConstants.default_data_converter
+        data_converter: FlowConstants.data_converter
       }
       # We first compare and remove the following values because these objects have issues
       # when we sort the values array below
-      [:data_converter, :manual_completion].each { |x| full_options.delete(x).should == expected.delete(x) }
+      full_options.delete(:data_converter).should be_kind_of(expected.delete(:data_converter).class)
+      full_options.delete(:manual_completion).should == expected.delete(:manual_completion)
       full_options.keys.sort.should == expected.keys.sort
       full_options.values.sort.should == expected.values.sort
     end
@@ -139,11 +140,12 @@ describe AWS::Flow::WorkflowRegistrationOptions do
         default_task_list: "USE_WORKER_TASK_LIST",
         default_task_priority: "0",
         tag_list: [],
-        data_converter: FlowConstants.default_data_converter
+        data_converter: FlowConstants.data_converter
       }
       # We first compare and remove the following values because these objects have issues
       # when we sort the values array below
-      [:data_converter, :tag_list].each { |x| full_options.delete(x).should == expected.delete(x) }
+      full_options.delete(:data_converter).should be_kind_of(expected.delete(:data_converter).class)
+      full_options.delete(:tag_list).should == expected.delete(:tag_list)
       full_options.keys.sort.should == expected.keys.sort
       full_options.values.sort.should == expected.values.sort
     end
@@ -167,12 +169,13 @@ describe AWS::Flow::WorkflowRegistrationOptions do
         default_task_priority: "0",
         version: "1.0",
         prefix_name: "FooActivity",
-        data_converter: FlowConstants.default_data_converter,
+        data_converter: FlowConstants.data_converter,
         tag_list: ["tag1", "tag2"]
       }
       # We first compare and remove the following values because these objects have issues
       # when we sort the values array below
-      [:data_converter, :tag_list].each { |x| full_options.delete(x).should == expected.delete(x) }
+      full_options.delete(:data_converter).should be_kind_of(expected.delete(:data_converter).class)
+      full_options.delete(:tag_list).should == expected.delete(:tag_list)
       full_options.keys.sort.should == expected.keys.sort
       full_options.values.sort.should == expected.values.sort
     end
@@ -188,12 +191,9 @@ describe AWS::Flow::ActivityOptions do
     it "should only contain the non registration options" do
       options = AWS::Flow::ActivityOptions.new
       full_options = options.get_full_options
-      expected = {
-        data_converter: FlowConstants.default_data_converter
-      }
       # We first compare and remove the following values because these objects have issues
       # when we sort the values array below
-      full_options.should == expected
+      full_options[:data_converter].should be_kind_of(FlowConstants.data_converter.class)
     end
 
     it "should return the values passed in" do
@@ -213,11 +213,12 @@ describe AWS::Flow::ActivityOptions do
         manual_completion: true,
         task_priority: "100",
         heartbeat_timeout: "10",
-        data_converter: FlowConstants.default_data_converter,
+        data_converter: FlowConstants.data_converter,
       }
       # We first compare and remove the following values because these objects have issues
       # when we sort the values array below
-      [:data_converter, :manual_completion].each { |x| full_options.delete(x).should == expected.delete(x) }
+      full_options.delete(:data_converter).should be_kind_of(expected.delete(:data_converter).class)
+      full_options.delete(:manual_completion).should == expected.delete(:manual_completion)
       full_options.keys.sort.should == expected.keys.sort
       full_options.values.sort.should == expected.values.sort
     end
@@ -232,12 +233,9 @@ describe AWS::Flow::WorkflowOptions do
     it "should not contain any registration options" do
       options = AWS::Flow::WorkflowOptions.new
       full_options = options.get_full_options
-      expected = {
-        data_converter: FlowConstants.default_data_converter
-      }
       # We first compare and remove the following values because these objects have issues
       # when we sort the values array below
-      full_options.should == expected
+      full_options[:data_converter].should be_kind_of(FlowConstants.data_converter.class)
     end
 
     it "should return the values passed in" do
@@ -253,11 +251,12 @@ describe AWS::Flow::WorkflowOptions do
         version: "1.0",
         prefix_name: "FooWorkflow",
         tag_list: ["tag1", "tag2"],
-        data_converter: FlowConstants.default_data_converter,
+        data_converter: FlowConstants.data_converter,
       }
       # We first compare and remove the following values because these objects have issues
       # when we sort the values array below
-      [:data_converter, :tag_list].each { |x| full_options.delete(x).should == expected.delete(x) }
+      full_options.delete(:data_converter).should be_kind_of(expected.delete(:data_converter).class)
+      full_options.delete(:tag_list).should == expected.delete(:tag_list)
       full_options.keys.sort.should == expected.keys.sort
       full_options.values.sort.should == expected.values.sort
     end
@@ -272,7 +271,7 @@ describe AWS::Flow::WorkflowRegistrationDefaults do
 
     it "should return the correct default values" do
       defaults = AWS::Flow::WorkflowRegistrationDefaults.new
-      defaults.data_converter.should == AWS::Flow::FlowConstants.default_data_converter
+      defaults.data_converter.should be_kind_of(AWS::Flow::FlowConstants.data_converter.class)
       defaults.default_task_start_to_close_timeout.should == 30
       defaults.default_child_policy.should == "TERMINATE"
       defaults.tag_list.should == []
@@ -290,7 +289,7 @@ describe AWS::Flow::ActivityRegistrationDefaults do
 
     it "should return the correct default values" do
       defaults = AWS::Flow::ActivityRegistrationDefaults.new
-      defaults.data_converter.should == AWS::Flow::FlowConstants.default_data_converter
+      defaults.data_converter.should be_kind_of(AWS::Flow::FlowConstants.data_converter.class)
       defaults.default_task_schedule_to_start_timeout.should == Float::INFINITY
       defaults.default_task_schedule_to_close_timeout.should == Float::INFINITY
       defaults.default_task_start_to_close_timeout.should == Float::INFINITY

data/spec/aws/decider/unit/retry_spec.rb

@@ -19,6 +19,14 @@ end
 
 describe "ExponentialRetry" do
 
+  before(:all) do
+    @bucket = ENV['AWS_SWF_BUCKET_NAME']
+    ENV['AWS_SWF_BUCKET_NAME'] = nil
+  end
+  after(:all) do
+    ENV['AWS_SWF_BUCKET_NAME'] = @bucket
+  end
+
   context "ActivityRetry" do
     # The following tests for github issue # 57
     before(:all) do

data/spec/aws/decider/unit/starter_spec.rb

@@ -0,0 +1,159 @@
+require_relative 'setup'
+
+describe "AWS::Flow" do
+
+  context "#start" do
+
+    it "calls AWS::Flow::Templates#start" do
+      AWS::Flow::stub(:start_workflow)
+      expect(AWS::Flow::Templates).to receive(:start)
+      AWS::Flow::start("HelloWorld.hello", { foo: "foo" })
+    end
+
+  end
+
+  context "#start_workflow" do
+
+    it "raises error if options are not passed in correctly" do
+      expect{AWS::Flow::start_workflow(nil, "input", nil)}.to raise_error(ArgumentError)
+      expect{AWS::Flow::start_workflow(nil, "input", "")}.to raise_error(ArgumentError)
+    end
+
+    it "raises error if domain is not provided" do
+
+      options = { from_class: "FooWorkflow" }
+      expect{AWS::Flow::start_workflow(nil, "input", options)}.to raise_error(ArgumentError)
+
+    end
+
+    it "raises error if workflow type or from_class is not provided" do
+
+      domain = double
+      AWS::Flow::Utilities.stub(:register_domain).and_return(domain)
+
+      options = { domain: "foo", prefix_name: "FooWorkflow" }
+      expect{AWS::Flow::start_workflow(nil, "input", options)}.to raise_error(ArgumentError)
+      options.merge!(execution_method: "foo")
+      expect{AWS::Flow::start_workflow(nil, "input", options)}.to raise_error(ArgumentError)
+
+      wf_client = double
+      expect(wf_client).to receive(:start_execution)
+
+      expect(AWS::Flow).to receive(:workflow_client) do |client, domain, &block|
+        wf_client
+      end
+
+      options.merge!(version: "1.0")
+      expect{AWS::Flow::start_workflow(nil, "input", options)}.not_to raise_error
+
+      expect(wf_client).to receive(:start_execution)
+
+      expect(AWS::Flow).to receive(:workflow_client) do |client, domain, &block|
+        wf_client
+      end
+
+      options = { domain: "foo", from_class: "foo" }
+      expect{AWS::Flow::start_workflow(nil, "input", options)}.not_to raise_error
+
+    end
+
+    it "starts a workflow with overriden options" do
+
+      domain = double
+      AWS::Flow::Utilities.stub(:register_domain).and_return(domain)
+      wf_client = double
+      expect(wf_client).to receive(:start_execution)
+
+      expect(AWS::Flow).to receive(:workflow_client) do |client, domain, &block|
+        options = block.call
+        options.should include(
+          prefix_name: "HelloWorld",
+          execution_method: "hello",
+          version: "2.0",
+          execution_start_to_close_timeout: 120,
+        )
+        wf_client
+      end
+
+      options = {
+        domain: "FooDomain",
+        execution_start_to_close_timeout: 120,
+        version: "2.0",
+      }
+
+      AWS::Flow::start_workflow("HelloWorld.hello", "input", options)
+
+    end
+
+    it "starts a regular workflow execution with correct options" do
+
+      domain = double
+      AWS::Flow::Utilities.stub(:register_domain).and_return(domain)
+      wf_client = double
+      expect(wf_client).to receive(:start_execution)
+
+      expect(AWS::Flow).to receive(:workflow_client) do |client, domain, &block|
+        options = block.call
+
+        options.should include(
+          prefix_name: "StarterTestWorkflow",
+          execution_method: "start"
+        )
+        wf_client
+      end
+
+      AWS::Flow::start_workflow("StarterTestWorkflow", "input", {
+        domain: "test",
+        execution_method: "start",
+        version: "1.0"
+      })
+
+    end
+
+    it "starts a workflow execution with all options in options hash" do
+
+      domain = double
+      AWS::Flow::Utilities.stub(:register_domain).and_return(domain)
+      wf_client = double
+      expect(wf_client).to receive(:start_execution)
+
+      expect(AWS::Flow).to receive(:workflow_client) do |client, domain, &block|
+        options = block.call
+
+        options.should include(
+          prefix_name: "FooWorkflow",
+          execution_method: "start",
+          version: "1.0"
+        )
+        wf_client
+      end
+
+      options = { prefix_name: "FooWorkflow", domain: "Foo", version: "1.0", execution_method: "start" }
+      AWS::Flow::start_workflow(nil, "input", options)
+
+    end
+
+
+    it "starts workflow with from_options option correctly" do
+
+      domain = double
+      AWS::Flow::Utilities.stub(:register_domain).and_return(domain)
+      wf_client = double
+      expect(wf_client).to receive(:start_execution)
+
+      class FooWorkflow; extend AWS::Flow::Workflows; end
+
+      expect(AWS::Flow).to receive(:workflow_client) do |client, domain, &block|
+        options = block.call
+        options.should include(from_class: "FooWorkflow")
+        wf_client
+      end
+
+      options = { domain: "Foo", from_class: "FooWorkflow" }
+      AWS::Flow::start_workflow(nil, "input", options)
+
+    end
+
+  end
+
+end

data/spec/aws/runner/integration/runner_integration_spec.rb

@@ -50,8 +50,7 @@ describe "Runner" do
 
     # This activity will say hello when invoked by the workflow
     def ping() 
-      puts "Pong from #{Socket.gethostbyname(Socket.gethostname).first}"
-      "Pong from #{Socket.gethostbyname(Socket.gethostname).first}"
+      "Pong from #{Socket.gethostname}"
     end
   end
 
@@ -134,7 +133,7 @@ describe "Runner" do
       # mock the load_files method to avoid having to create default files
       AWS::Flow::Runner.stub(:load_files)
 
-      workers = AWS::Flow::Runner.start_workers("", runner_config)
+      workers = AWS::Flow::Runner.start_workers(runner_config)
 
       sleep 2
       utils  = PingUtils.new

data/spec/aws/runner/unit/runner_unit_spec.rb

@@ -64,6 +64,9 @@ describe "Runner" do
 
       # just in case so we don't start chid processes
       AWS::Flow::Runner.stub(:fork)
+      allow(AWS::Flow::Runner).to receive(:all_subclasses).and_return(nil)
+
+      AWS::Flow::Runner.stub(:setup_domain)
 
       # make sure the error is thrown
       expect {
@@ -86,6 +89,9 @@ describe "Runner" do
 
       # just in case so we don't start chid processes
       allow(AWS::Flow::Runner).to receive(:fork).and_return(42)
+      allow(AWS::Flow::Runner).to receive(:all_subclasses).and_return(nil)
+
+      AWS::Flow::Runner.stub(:setup_domain)
 
       # make sure the error is thrown
       expect {
@@ -109,6 +115,9 @@ describe "Runner" do
 
       # just in case so we don't start chid processes
       AWS::Flow::Runner.stub(:fork)
+      allow(AWS::Flow::Runner).to receive(:all_subclasses).and_return(nil)
+
+      AWS::Flow::Runner.stub(:setup_domain)
 
       # make sure the error is thrown
       expect {
@@ -131,6 +140,9 @@ describe "Runner" do
 
       # just in case so we don't start chid processes
       allow(AWS::Flow::Runner).to receive(:fork).and_return(42)
+      allow(AWS::Flow::Runner).to receive(:all_subclasses).and_return(nil)
+
+      AWS::Flow::Runner.stub(:setup_domain)
 
       # make sure the error is thrown
       expect {
@@ -143,34 +155,59 @@ describe "Runner" do
 
   describe "Starting workers" do
 
+    before(:all) do
+      class Foo; extend AWS::Flow::Workflows; end
+      class Bar; extend AWS::Flow::Workflows; end
+      class FooActivity; extend AWS::Flow::Activities; end
+      class BarActivity; extend AWS::Flow::Activities; end
+
+    end
+
     def workflow_js
-      document = '{
+      JSON.parse('{
         "workflow_paths": [],
         "workflow_workers": [
           {
             "task_list": "bar",
-            "workflow_classes": [ "Object", "String" ],
+            "workflow_classes": [ "Foo", "Bar" ],
             "number_of_workers": 3
           }
         ]
-      }'
-      JSON.parse(document)
+      }')
     end
 
     def activity_js
-      document = '{
+      JSON.parse('{
         "activity_paths": [],
         "activity_workers": [
           {
             "task_list": "bar",
-            "activity_classes": [ "Object", "String" ],
+            "activity_classes": [ "FooActivity", "BarActivity" ],
             "number_of_workers": 3
           }
         ]
-      }'
-      JSON.parse(document)
+      }')
+    end
+
+    def default_js
+      JSON.parse('{
+        "default_workers":
+          {
+            "number_of_workers": 3
+          }
+      }')
     end
 
+    def default_js_0
+      JSON.parse('{
+        "default_workers":
+          {
+            "number_of_workers": 0
+          }
+      }')
+    end
+
+
     it "makes sure the number of workflow workers is correct" do
       # mock out a few methods to focus on the fact that the workers were created
       allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:add_implementation).and_return(nil)
@@ -182,7 +219,7 @@ describe "Runner" do
       # what we are testing:
       expect(AWS::Flow::Runner).to receive(:fork).exactly(3).times
 
-      # start the workers 
+      # start the workers
       workers = AWS::Flow::Runner.start_workflow_workers(AWS::SimpleWorkflow.new, "", workflow_js)
     end
 
@@ -194,11 +231,12 @@ describe "Runner" do
       allow_any_instance_of(AWS::Flow::ActivityWorker).to receive(:start).and_return(nil)
       AWS::Flow::Runner.stub(:setup_domain)
       AWS::Flow::Runner.stub(:load_files)
+      AWS::Flow::Runner.stub(:start_default_workers)
 
       # what we are testing:
       expect(AWS::Flow::Runner).to receive(:fork).exactly(3).times
 
-      # start the workers 
+      # start the workers
       workers = AWS::Flow::Runner.start_activity_workers(AWS::SimpleWorkflow.new, "",activity_js)
     end
     
@@ -215,11 +253,11 @@ describe "Runner" do
         implems << arg
       end
 
-      # start the workers 
+      # start the workers
       workers = AWS::Flow::Runner.start_workflow_workers(AWS::SimpleWorkflow.new, "",workflow_js)
 
       # validate
-      expect(implems).to include(Object.const_get("Object"), Object.const_get("String"))
+      expect(implems).to include(Object.const_get("Foo"), Object.const_get("Bar"))
     end
 
     it "makes sure the activity implementation classes are added" do
@@ -228,6 +266,8 @@ describe "Runner" do
       AWS::Flow::Runner.stub(:fork)
       AWS::Flow::Runner.stub(:load_files)
       AWS::Flow::Runner.stub(:setup_domain)
+      AWS::Flow::Templates.stub(:make_activity_class).and_return{ |x| x }
+      AWS::Flow::Runner.stub(:start_default_workers)
       
       # stub that we can query later
       implems = []
@@ -235,11 +275,11 @@ describe "Runner" do
         implems << arg
       end
 
-      # start the workers 
+      # start the workers
       workers = AWS::Flow::Runner.start_activity_workers(AWS::SimpleWorkflow.new, "",activity_js)
 
       # validate
-      expect(implems).to include(Object.const_get("Object"), Object.const_get("String"))
+      expect(implems).to include(Object.const_get("FooActivity"), Object.const_get("BarActivity"))
     end
 
     it "makes sure the workflow worker is started" do
@@ -255,7 +295,7 @@ describe "Runner" do
         starts += 1
       end
 
-      # start the workers 
+      # start the workers
       workers = AWS::Flow::Runner.start_workflow_workers(AWS::SimpleWorkflow.new, "",workflow_js)
 
       # validate
@@ -268,6 +308,7 @@ describe "Runner" do
       AWS::Flow::Runner.stub(:fork).and_yield
       AWS::Flow::Runner.stub(:load_files)
       AWS::Flow::Runner.stub(:setup_domain)
+      AWS::Flow::Runner.stub(:start_default_workers)
       
       # stub that we can query later
       starts = 0
@@ -275,13 +316,73 @@ describe "Runner" do
         starts += 1
       end
 
-      # start the workers 
+      # start the workers
       workers = AWS::Flow::Runner.start_activity_workers(AWS::SimpleWorkflow.new, "",activity_js)
 
       # validate
       expect(starts).to equal(3)
     end
 
+    it "makes sure the number of default workers is correct when stated explicitly" do
+      # mock out a few methods to focus on the fact that the workers were created
+      allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:add_implementation) do |klass|
+        klass.should be(AWS::Flow::Templates.default_workflow)
+        nil
+      end
+
+      allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:start).and_return(nil)
+      AWS::Flow::Runner.stub(:setup_domain)
+      AWS::Flow::Runner.stub(:load_files)
+      AWS::Flow::Templates.stub(:register_default_result_activity)
+
+      # what we are testing:
+      expect(AWS::Flow::Runner).to receive(:fork).exactly(3).times
+
+      # start the workers
+      workers = AWS::Flow::Runner.start_default_workers(AWS::SimpleWorkflow.new, "", default_js)
+    end
+
+    it "makes sure the number of default workers is 0 when stated so explicitly" do
+      # mock out a few methods to focus on the fact that the workers were created
+      allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:add_implementation) do |klass|
+        klass.should be(AWS::Flow::Templates.default_workflow)
+        nil
+      end
+
+      allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:start).and_return(nil)
+      AWS::Flow::Runner.stub(:setup_domain)
+      AWS::Flow::Runner.stub(:load_files)
+      AWS::Flow::Templates.stub(:register_default_result_activity)
+
+      # what we are testing:
+      expect(AWS::Flow::Runner).to receive(:fork).exactly(0).times
+
+      # start the workers
+      workers = AWS::Flow::Runner.start_default_workers(AWS::SimpleWorkflow.new, "", default_js_0)
+    end
+
+    it "makes sure the number of default workers is correct when stated implicitly" do
+      # mock out a few methods to focus on the fact that the workers were created
+      allow_any_instance_of(AWS::Flow::ActivityWorker).to receive(:add_implementation).and_return(nil)
+      allow_any_instance_of(AWS::Flow::ActivityWorker).to receive(:start).and_return(nil)
+
+      allow_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:add_implementation) do |klass|
+        klass.should be(AWS::Flow::Templates.default_workflow)
+        nil
+      end
+
+      AWS::Flow::Runner.stub(:setup_domain)
+      AWS::Flow::Runner.stub(:load_files)
+      AWS::Flow::Templates.stub(:register_default_result_activity)
+
+      # what we are testing:
+      expect(AWS::Flow::Runner).to receive(:fork).exactly(6).times
+
+      # start the workers
+      workers = AWS::Flow::Runner.start_activity_workers(AWS::SimpleWorkflow.new, "",activity_js)
+
+    end
+
   end
 
 
@@ -321,33 +422,20 @@ describe "Runner" do
                                     default_file: relative})
     end
 
-    it "loads the \"flow/activities.rb\" by default for activity worker" do
+    it "loads the \"flow/activities.rb\" and \"flow/workflows.rb\" by default for activity and workflow worker respectively" do
       def activity_js
         document = '{
         "activity_workers": [
           {
             "task_list": "bar",
-            "activity_classes": [ "Object", "String" ],
+            "activity_classes": [ "FooActivity", "BarActivity" ],
             "number_of_workers": 3
           }
-        ]
-      }'
-        JSON.parse(document)
-      end
-
-      AWS::Flow::Runner.stub(:setup_domain)
-      expect(AWS::Flow::Runner).to receive(:require).with(File.join(".", "flow", "activities.rb"))
-
-      AWS::Flow::Runner.start_activity_workers(AWS::SimpleWorkflow.new, ".", activity_js)
-    end
-
-    it "loads the \"flow/workflows.rb\" by default for workflow worker" do
-      def workflow_js
-        document = '{
+        ],
         "workflow_workers": [
           {
             "task_list": "bar",
-            "workflow_classes": [ "Object", "String" ],
+            "workflow_classes": [ "Foo", "Bar" ],
             "number_of_workers": 3
           }
         ]
@@ -356,9 +444,10 @@ describe "Runner" do
       end
 
       AWS::Flow::Runner.stub(:setup_domain)
+      expect(AWS::Flow::Runner).to receive(:require).with(File.join(".", "flow", "activities.rb"))
       expect(AWS::Flow::Runner).to receive(:require).with(File.join(".", "flow", "workflows.rb"))
 
-      AWS::Flow::Runner.start_workflow_workers(AWS::SimpleWorkflow.new, ".", workflow_js)
+      AWS::Flow::Runner.load_classes(".", activity_js)
     end
 
     it "takes activity_paths as override to \"flow/activities.rb\"" do
@@ -368,7 +457,7 @@ describe "Runner" do
         "activity_workers": [
           {
             "task_list": "bar",
-            "activity_classes": [ "Object", "String" ],
+            "activity_classes": [ "FooActivity", "BarActivity" ],
             "number_of_workers": 3
           }
         ]
@@ -381,7 +470,7 @@ describe "Runner" do
       expect(AWS::Flow::Runner).to receive(:require).with(File.join("foo"))
       expect(AWS::Flow::Runner).to receive(:require).with(File.join("bar"))
 
-      AWS::Flow::Runner.start_activity_workers(AWS::SimpleWorkflow.new, ".", activity_js)
+      AWS::Flow::Runner.load_classes(".", activity_js)
     end
 
     it "takes workflow_paths as override to \"flow/workflows.rb\"" do
@@ -391,7 +480,7 @@ describe "Runner" do
         "workflow_workers": [
           {
             "task_list": "bar",
-            "workflow_classes": [ "Object", "String" ],
+            "workflow_classes": [ "Foo", "Bar" ],
             "number_of_workers": 3
           }
         ]
@@ -404,7 +493,7 @@ describe "Runner" do
       expect(AWS::Flow::Runner).to receive(:require).with(File.join("foo"))
       expect(AWS::Flow::Runner).to receive(:require).with(File.join("bar"))
 
-      AWS::Flow::Runner.start_workflow_workers(AWS::SimpleWorkflow.new, ".", workflow_js)
+      AWS::Flow::Runner.load_classes(".", workflow_js)
     end
 
   end
@@ -480,6 +569,7 @@ describe "Runner" do
       AWS::Flow::ActivityWorker.any_instance.stub(:add_implementation) do |impl|
         impls << impl
       end
+      AWS::Flow::Runner.stub(:start_default_workers)
 
       AWS::Flow::Runner.start_activity_workers(AWS::SimpleWorkflow.new, ".", activity_js)