aws-flow 1.1.1 → 1.2.0

data/lib/aws/decider/workflow_client.rb

@@ -306,7 +306,7 @@ module AWS
                 state_machine = @decision_helper[workflow_id.to_s]
                 if state_machine.current_state == :created
                   open_request = @decision_helper.scheduled_external_workflows.delete(workflow_id)
-                  open_request.complete
+                  open_request.completion_handle.complete
                 end
                 state_machine.consume(:cancel)
               end

data/spec/aws/integration/integration_spec.rb

@@ -192,7 +192,12 @@ describe "RubyFlowDecider" do
       sleep 3
       workflow_type, _ = @domain.workflow_types.page(:per_page => 1000).select {|x| x.name == workflow_type_name}
 
-      workflow_execution = workflow_type.start_execution(:execution_start_to_close_timeout => 3600, :task_list => task_list, :task_start_to_close_timeout => 3600, :child_policy => :request_cancel)
+      workflow_execution = workflow_type.start_execution(
+        :execution_start_to_close_timeout => 3600,
+        :task_list => task_list,
+        :task_start_to_close_timeout => 3600,
+        :child_policy => :request_cancel
+      )
       worker.run_once
       activity_worker.run_once
       worker.run_once
@@ -246,7 +251,18 @@ describe "RubyFlowDecider" do
       activity_worker.register
       sleep 3
       workflow_id = "basic_activity_workflow"
-      run_id = @swf.client.start_workflow_execution(:execution_start_to_close_timeout => "3600", :task_list => {:name => task_list}, :task_start_to_close_timeout => "3600", :child_policy => "REQUEST_CANCEL", :workflow_type => {:name => workflow_type_name, :version => "1"}, :workflow_id => workflow_id, :domain => @domain.name.to_s)
+      run_id = @swf.client.start_workflow_execution(
+        :execution_start_to_close_timeout => "3600",
+        :task_list => {:name => task_list},
+        :task_start_to_close_timeout => "3600",
+        :child_policy => "REQUEST_CANCEL",
+        :workflow_type => {
+          :name => workflow_type_name,
+          :version => "1"
+        },
+        :workflow_id => workflow_id,
+        :domain => @domain.name.to_s
+      )
       workflow_execution = AWS::SimpleWorkflow::WorkflowExecution.new(@domain, workflow_id, run_id["runId"])
       @forking_executor = ForkingExecutor.new(:max_workers => 3)
       @forking_executor.execute { worker.start }
@@ -379,7 +395,12 @@ describe "RubyFlowDecider" do
       workflow_type_name = "LargeWorkflow.entry_point"
       workflow_type, _ = @domain.workflow_types.page(:per_page => 1000).select {|x| x.name == workflow_type_name}
 
-      workflow_execution = workflow_type.start_execution(:execution_start_to_close_timeout => 3600, :task_list => task_list, :task_start_to_close_timeout => 15, :child_policy => :request_cancel)
+      workflow_execution = workflow_type.start_execution(
+        :execution_start_to_close_timeout => 3600,
+        :task_list => task_list,
+        :task_start_to_close_timeout => 15,
+        :child_policy => :request_cancel
+      )
       @forking_executor = ForkingExecutor.new(:max_workers => 5)
       @forking_executor.execute { activity_worker.start }
 
@@ -508,7 +529,14 @@ describe "RubyFlowDecider" do
     @activity_class = Object.const_set("#{class_name}Activity", new_activity_class)
     new_workflow_class = Class.new(ParentWorkflow) do
       extend Workflows
-      workflow(:entry_point) { {:version => 1, :execution_start_to_close_timeout => 3600, :task_list => task_list , :prefix_name => "#{class_name}Workflow"} }
+      workflow(:entry_point) {
+        {
+          :version => 1,
+          :execution_start_to_close_timeout => 120,
+          :task_list => task_list,
+          :prefix_name => "#{class_name}Workflow"
+        }
+      }
       def entry_point
         activity.run_activity1
       end
@@ -611,8 +639,8 @@ describe "RubyFlowDecider" do
         {
           :default_task_heartbeat_timeout => "3600",
           :default_task_list => task_list,
-          :task_schedule_to_start_timeout => 120,
-          :task_start_to_close_timeout => 120,
+          :default_task_schedule_to_start_timeout => 120,
+          :default_task_start_to_close_timeout => 120,
           :version => "1",
           :manual_completion => true
         }
@@ -1017,7 +1045,13 @@ describe "RubyFlowDecider" do
       @worker.run_once
       history = workflow_execution.events.map(&:event_type)
       history.last.should == "WorkflowExecutionFailed"
-      # Should look something like: ["WorkflowExecutionStarted", "DecisionTaskScheduled", "DecisionTaskStarted", "DecisionTaskCompleted", "ActivityTaskScheduled", "ActivityTaskScheduled", "ActivityTaskStarted", "ActivityTaskFailed", "DecisionTaskScheduled", "DecisionTaskStarted", "DecisionTaskCompleted", "ActivityTaskCancelRequested", "ActivityTaskCanceled", "DecisionTaskScheduled", "DecisionTaskStarted", "DecisionTaskCompleted", "WorkflowExecutionFailed"]
+      # Should look something like: ["WorkflowExecutionStarted",
+      # "DecisionTaskScheduled", "DecisionTaskStarted", "DecisionTaskCompleted",
+      # "ActivityTaskScheduled", "ActivityTaskScheduled", "ActivityTaskStarted",
+      # "ActivityTaskFailed", "DecisionTaskScheduled", "DecisionTaskStarted",
+      # "DecisionTaskCompleted", "ActivityTaskCancelRequested",
+      # "ActivityTaskCanceled", "DecisionTaskScheduled", "DecisionTaskStarted",
+      # "DecisionTaskCompleted", "WorkflowExecutionFailed"]
       history.should include "ActivityTaskCancelRequested"
     end
 
@@ -1025,7 +1059,11 @@ describe "RubyFlowDecider" do
       general_test(:task_list => "exponential_retry_key", :class_name => "ExponentialRetryKey")
       @workflow_class.class_eval do
         def entry_point
-          activity.reconfigure(:run_activity1) { {:exponential_retry => {:maximum_attempts => 1}, :task_schedule_to_start_timeout => 5} }
+          activity.reconfigure(:run_activity1) {
+            {
+              :exponential_retry => {:maximum_attempts => 1},
+              :default_task_schedule_to_start_timeout => 5}
+          }
           activity.run_activity1
         end
       end
@@ -1318,15 +1356,6 @@ describe "RubyFlowDecider" do
     end
     it "makes sure that you can have an asynchronous timer with a block" do
       general_test(:task_list => "async_timer_with_block", :class_name => "AsyncBlock")
-      @activity_class.class_eval do
-        def run_activity2
-        end
-        activity :run_activity2 do |options|
-          options.default_task_heartbeat_timeout = "3600"
-          options.default_task_list = self.task_list
-          options.version = "1"
-        end
-      end
       @workflow_class.class_eval do
         def entry_point
           create_timer_async(5) { activity.run_activity1 }
@@ -2115,7 +2144,6 @@ describe "RubyFlowDecider" do
     # Sleep to give the threads some time to compute, as we'll run right out of
     # the test before they can run otherwise
     sleep 50
-    p workflow_execution.events.to_a
     workflow_execution.events.map(&:event_type).count("WorkflowExecutionCompleted").should == 1
   end
 
@@ -2228,7 +2256,6 @@ describe "RubyFlowDecider" do
     #     end
     #   end
     # end
-    # debugger
 
     worker.run_once
     activity_worker.run_once
@@ -2384,7 +2411,9 @@ describe "RubyFlowDecider" do
             options.version = "1"
             options.task_list = "client_test_async2"
           end
-          client.send_async(:start_execution, arg) { {:task_start_to_close_timeout => 35 } }
+          client.send_async(:start_execution, arg) {
+            { :task_start_to_close_timeout => 35 }
+          }
           client.send_async(:start_execution, arg)
         end
       end
@@ -3080,23 +3109,16 @@ describe "RubyFlowDecider" do
 
   it "ensures you can use manual completion" do
     general_test(:task_list => "manual_completion", :class_name => "ManualCompletion")
-    @activity_class.class_eval do
-      activity :run_activity1 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
-    end
+
     activity_worker = ActivityWorker.new(@swf.client, @domain, "manual_completion", @activity_class)
     activity_worker.register
     @workflow_class.class_eval do
+      activity_client(:activity1) { {
+        from_class: self.activity_class,
+        manual_completion: true
+      } }
       def entry_point
-        activity.run_activity1
+        activity.run_activity2
       end
     end
     workflow_execution = @my_workflow_client.start_execution

data/spec/aws/unit/decider_spec.rb

@@ -105,7 +105,7 @@ class FakeWorkflowExecution
     @run_id = run_id
     @workflow_id = workflow_id
   end
-  attr_accessor :run_id, :workflow_id
+  attr_accessor :run_id, :workflow_id, :task_list
 end
 
 class FakeWorkflowExecutionCollecton
@@ -507,7 +507,7 @@ describe "FakeHistory" do
 
 
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_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=> fake_workflow_type, :task_list=>"BadWorkflow"}),
@@ -521,7 +521,6 @@ describe "FakeHistory" do
     worker.start
     # @forking_executor.execute { activity_worker.start }
 
-    # debugger
     # worker.start
     swf_client.trace.first[:decisions].first[:decision_type].should ==
       "CompleteWorkflowExecution"
@@ -529,7 +528,7 @@ describe "FakeHistory" do
 
   it "reproduces the ActivityTaskTimedOut problem" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type =  FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -567,7 +566,6 @@ describe "FakeHistory" do
     workflow_type_object = double("workflow_type", :name => "BadWorkflow.entry_point", :start_execution => "" )
     domain = FakeDomain.new(workflow_type_object)
 
-
     swf_client = FakeServiceClient.new
     task_list = "BadWorkflow_tasklist"
     worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list)
@@ -592,7 +590,7 @@ describe "FakeHistory" do
 
   it "makes sure that exponential retry can take arguments" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -646,7 +644,7 @@ describe "FakeHistory" do
 
   it "makes sure that overriding works correctly" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -699,7 +697,7 @@ describe "FakeHistory" do
 
   it "makes sure that exponential_retry blocks correctly" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -761,7 +759,7 @@ describe "FakeHistory" do
 
   it "makes sure that exponential_retry blocks correctly when done through configure" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -829,7 +827,7 @@ describe "FakeHistory" do
 
   it "makes sure that exponential_retry blocks correctly when done through the activity_client" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -897,7 +895,7 @@ describe "FakeHistory" do
 
   it "makes sure that multiple schedules followed by a timeout work" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -974,7 +972,7 @@ describe "FakeHistory" do
 
   it "makes sure that timeout followed by success is handled correctly" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -1053,7 +1051,7 @@ describe "FakeHistory" do
 
   it "makes sure that signal works correctly" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -1119,7 +1117,7 @@ describe "FakeHistory" do
 
   it "makes sure that raising an error properly fails a workflow" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type =  FakeWorkflowType.new(nil, "BadWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -1162,7 +1160,7 @@ describe "FakeHistory" do
   it "makes sure that you can do retry with the easier Fixnum semantic"do
 
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "FixnumWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -1211,7 +1209,7 @@ describe "FakeHistory" do
   it "ensures that CompleteWorkflowExecutionFailed is correctly handled" do
 
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "CompleteWorkflowExecutionFailedWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                [
@@ -1278,7 +1276,7 @@ describe "FakeHistory" do
 
   it "ensures that time outs do not cause problems" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "TimeOutWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                FakeEvents.new(["WorkflowExecutionStarted",
@@ -1343,7 +1341,7 @@ describe "FakeHistory" do
 
   it "ensures that the other timeout issue is not a problem" do
     class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
-      def get_decision_tasks
+      def get_decision_task
         fake_workflow_type = FakeWorkflowType.new(nil, "OtherTimeOutWorkflow.entry_point", "1")
         TestHistoryWrapper.new(fake_workflow_type,
                                FakeEvents.new(["WorkflowExecutionStarted",
@@ -1490,6 +1488,11 @@ describe "Misc tests" do
     workflow = client.start_external_workflow
     workflow.workflow_id.should match(regex)
   end
+  it "makes sure complete method is present on the completion handle and not open request" do
+    ( OpenRequestInfo.new.respond_to? :complete ).should == false
+    task = ExternalTask.new({}) { |t| puts t }
+    ( ExternalTaskCompletionHandle.new(task).respond_to? :complete ).should == true
+  end
 end
 
 
@@ -1564,7 +1567,7 @@ class TestActivityWorker < ActivityWorker
 end
 
 class FakeTaskPoller < WorkflowTaskPoller
-  def get_decision_tasks
+  def get_decision_task
     nil
   end
 end

data/spec/aws/unit/executor_spec.rb

@@ -0,0 +1,49 @@
+##
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License").
+# You may not use this file except in compliance with the License.
+# A copy of the License is located at
+#
+#  http://aws.amazon.com/apache2.0
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+##
+
+require 'aws/decider'
+
+describe AWS::Flow::ForkingExecutor do
+  context "#remove_completed_pids" do
+    context "with block=false" do
+      it "should reap all completed child processes" do
+        executor = AWS::Flow::ForkingExecutor.new(max_workers: 3)
+
+        executor.execute { sleep 1 }
+        executor.execute { sleep 1 }
+        executor.execute { sleep 5 }
+        executor.pids.size.should == 3
+        sleep 2
+        executor.send(:remove_completed_pids, false)
+        # The two processes that are completed will be reaped.
+        executor.pids.size.should == 1
+      end
+    end
+    context "with block=true" do
+      it "should wait for and reap the first child process available" do
+        executor = AWS::Flow::ForkingExecutor.new(max_workers: 3)
+
+        executor.execute { sleep 1 }
+        executor.execute { sleep 1 }
+        executor.execute { sleep 5 }
+        executor.pids.size.should == 3
+        sleep 2
+        executor.send(:remove_completed_pids, true)
+        # One of the two processes that are completed will be reaped
+        executor.pids.size.should == 2
+      end
+    end
+  end
+end

data/spec/aws/unit/options_spec.rb

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+describe AWS::Flow::OptionsMethods do
+
+  class FooDefaults < AWS::Flow::Defaults
+    def default_foo; 1; end
+    def default_baz; 2; end
+    def default_xyz; 3; end
+  end
+  class FooOptions < AWS::Flow::Options
+    include AWS::Flow::OptionsMethods
+    property(:default_foo)
+    property(:foo)
+    property(:bar)
+    property(:baz)
+    property(:xyz)
+    property(:default_baz)
+    default_classes << FooDefaults.new
+
+    def default_keys
+      [:default_foo, :default_baz, :default_xyz]
+    end
+    def make_runtime_key(key)
+      key.to_s.gsub(/default_/, "").to_sym
+    end
+  end
+
+  context "#get_full_options" do
+    it "should return merged default and regular options" do
+      options = FooOptions.new(
+        default_foo: 10,
+        bar: 10,
+        xyz: 10
+      )
+      options.get_full_options[:foo].should == "10"
+      options.get_full_options[:bar].should == "10"
+      options.get_full_options[:baz].should == "2"
+      options.get_full_options[:xyz].should == "10"
+
+    end
+  end
+
+  context "#get_runtime_options" do
+    it "should return the runtime values for the default options" do
+      options = FooOptions.new(
+        default_foo: 10,
+        bar: 10
+      )
+      options.get_runtime_options.has_key?(:foo).should == true
+      options.get_runtime_options.has_key?(:baz).should == true
+      options.get_runtime_options[:foo].should == "10"
+      options.get_runtime_options[:baz].should == "2"
+      options.get_runtime_options.has_key?(:bar).should == false
+    end
+  end
+  context "#get_default_options" do
+    it "should return the default values for the default options" do
+      options = FooOptions.new(
+        default_foo: 10,
+        baz: 10
+      )
+      options.get_default_options.has_key?(:default_foo).should == true
+      options.get_default_options.has_key?(:default_baz).should == true
+      options.get_default_options[:default_foo].should == "10"
+      options.get_default_options[:default_baz].should == "2"
+    end
+  end
+end
+
+describe AWS::Flow::ActivityOptions do
+  context "#defaults" do
+    it "should be initialized correctly" do
+      options = AWS::Flow::ActivityOptions.new
+      options.default_task_schedule_to_start_timeout.should == "NONE"
+      options.default_task_schedule_to_close_timeout.should == "NONE"
+      options.default_task_start_to_close_timeout.should == "NONE"
+      options.default_task_heartbeat_timeout.should == "NONE"
+      options.data_converter.should ==
+        AWS::Flow::FlowConstants.default_data_converter
+    end
+
+    it "should change to the value passed in" do
+      options = AWS::Flow::ActivityOptions.new({
+        default_task_schedule_to_start_timeout: 20,
+        default_task_schedule_to_close_timeout: 50,
+        default_task_start_to_close_timeout: 30,
+        default_task_heartbeat_timeout: 5,
+      })
+      options.default_task_schedule_to_start_timeout.should == "20"
+      options.default_task_schedule_to_close_timeout.should == "50"
+      options.default_task_start_to_close_timeout.should == "30"
+      options.default_task_heartbeat_timeout.should == "5"
+    end
+
+    it "should remain the same when a non default value is set" do
+      options = AWS::Flow::ActivityOptions.new
+      options.schedule_to_start_timeout = 20
+      options.schedule_to_close_timeout = 50
+      options.start_to_close_timeout = 30
+      options.heartbeat_timeout = 5
+
+      options.default_task_schedule_to_start_timeout.should == "NONE"
+      options.default_task_schedule_to_close_timeout.should == "NONE"
+      options.default_task_start_to_close_timeout.should == "NONE"
+      options.default_task_heartbeat_timeout.should == "NONE"
+    end
+
+    it "should not override non default values when non default values are set" do
+      options = AWS::Flow::ActivityOptions.new
+      options.schedule_to_start_timeout = 20
+      options.schedule_to_close_timeout = 50
+      options.start_to_close_timeout = 30
+      options.heartbeat_timeout = 5
+
+      options.schedule_to_start_timeout.should == "20"
+      options.schedule_to_close_timeout.should == "50"
+      options.start_to_close_timeout.should == "30"
+      options.heartbeat_timeout.should == "5"
+    end
+
+
+  end
+
+  context "#default_keys" do
+    it "should return the correct set of default keys" do
+      AWS::Flow::ActivityOptions.new.default_keys.should == [
+        :default_task_heartbeat_timeout,
+        :default_task_schedule_to_close_timeout,
+        :default_task_schedule_to_start_timeout,
+        :default_task_start_to_close_timeout,
+        :default_task_list
+      ]
+    end
+
+  end
+  context "#make_runtime_key" do
+    it "should correctly convert default keys to runtime keys" do
+      AWS::Flow::ActivityOptions.new.make_runtime_key(
+        :default_task_foo
+      ).should == :foo
+    end
+
+    it "should do nothing if an option without leading default_ is passed in" do
+      AWS::Flow::ActivityOptions.new.make_runtime_key(:foo).should == :foo
+    end
+
+    it "should handle the special case of default_task_list properly" do
+      AWS::Flow::ActivityOptions.new.make_runtime_key(
+        :default_task_list
+      ).should == :task_list
+    end
+  end
+end
+
+describe AWS::Flow::WorkflowOptions do
+  context "#defaults" do
+    it "should be initialized correctly" do
+      options = AWS::Flow::WorkflowOptions.new
+      options.default_task_start_to_close_timeout.should == "30"
+      options.default_child_policy.should == "TERMINATE"
+      options.tag_list.should == []
+      options.data_converter.should ==
+        AWS::Flow::FlowConstants.default_data_converter
+    end
+
+    it "should change to the value passed in" do
+      options = AWS::Flow::WorkflowOptions.new({
+        default_task_start_to_close_timeout: 20,
+        default_execution_start_to_close_timeout: 120,
+        default_child_policy: "ABANDON",
+      })
+      options.default_task_start_to_close_timeout.should == "20"
+      options.default_execution_start_to_close_timeout.should == "120"
+      options.default_child_policy.should == "ABANDON"
+    end
+
+    it "should remain the same when a non default value is set" do
+      options = AWS::Flow::WorkflowOptions.new
+      options.task_start_to_close_timeout = 20
+      options.execution_start_to_close_timeout = 120
+      options.child_policy = "ABANDON"
+
+      options.default_task_start_to_close_timeout.should == "30"
+      options.default_execution_start_to_close_timeout.nil?.should == true
+      options.default_child_policy.should == "TERMINATE"
+    end
+
+    it "should not override non default values when non default values are set" do
+      options = AWS::Flow::WorkflowOptions.new
+      options.task_start_to_close_timeout = 20
+      options.execution_start_to_close_timeout = 120
+      options.child_policy = "ABANDON"
+
+      options.task_start_to_close_timeout.should == "20"
+      options.execution_start_to_close_timeout.should == "120"
+      options.child_policy.should == "ABANDON"
+    end
+
+  end
+
+  context "#default_keys" do
+    it "should return the correct set of default keys" do
+      AWS::Flow::WorkflowOptions.new.default_keys.should == [
+        :default_task_start_to_close_timeout,
+        :default_execution_start_to_close_timeout,
+        :default_task_list,
+        :default_child_policy
+      ]
+    end
+
+  end
+  context "#make_runtime_key" do
+    it "should correctly convert default keys to runtime keys" do
+      AWS::Flow::WorkflowOptions.new.make_runtime_key(
+        :default_foo
+      ).should == :foo
+    end
+
+    it "should do nothing if an option without leading default_ is passed in" do
+      AWS::Flow::WorkflowOptions.new.make_runtime_key(:foo).should == :foo
+    end
+
+    it "should handle the special case of default_task_list properly" do
+      AWS::Flow::WorkflowOptions.new.make_runtime_key(
+        :default_task_list
+      ).should == :task_list
+    end
+  end
+
+end
+
+describe AWS::Flow::WorkflowDefaults do
+  context "#default_task_start_to_close_timeout" do
+    it "should return a value of 30" do
+      AWS::Flow::WorkflowDefaults.new.default_task_start_to_close_timeout
+      .should == 30
+    end
+  end
+
+  context "#default_child_policy" do
+    it "should return TERMINATE" do
+      AWS::Flow::WorkflowDefaults.new.default_child_policy.should == "TERMINATE"
+    end
+  end
+
+  context "#tag_list" do
+    it "should return an empty array" do
+      AWS::Flow::WorkflowDefaults.new.tag_list.should == []
+    end
+  end
+
+  context "#data_converter" do
+    it "should return the default data converter" do
+      AWS::Flow::WorkflowDefaults.new.data_converter
+      .should == AWS::Flow::FlowConstants.default_data_converter
+    end
+  end
+end
+
+describe AWS::Flow::ActivityDefaults do
+  context "#default_task_schedule_to_start_timeout" do
+    it "should return Float::INFINITY" do
+      AWS::Flow::ActivityDefaults.new.default_task_schedule_to_start_timeout
+      .should == Float::INFINITY
+    end
+  end
+
+  context "#default_task_schedule_to_close_timeout" do
+    it "should return Float::INFINITY" do
+      AWS::Flow::ActivityDefaults.new.default_task_schedule_to_close_timeout
+      .should == Float::INFINITY
+    end
+  end
+  context "#default_task_start_to_close_timeout" do
+    it "should return Float::INFINITY" do
+      AWS::Flow::ActivityDefaults.new.default_task_start_to_close_timeout
+      .should == Float::INFINITY
+    end
+  end
+  context "#default_task_heartbeat_timeout" do
+    it "should return Float::INFINITY" do
+      AWS::Flow::ActivityDefaults.new.default_task_heartbeat_timeout
+      .should == Float::INFINITY
+    end
+  end
+  context "#data_converter" do
+    it "should return the default data converter" do
+      AWS::Flow::ActivityDefaults.new.data_converter
+      .should == AWS::Flow::FlowConstants.default_data_converter
+    end
+  end
+end
+