aws-flow 1.3.0 → 2.0.0

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

@@ -0,0 +1,123 @@
+##
+# 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_relative 'setup'
+
+describe ForkingExecutor do
+
+  it "makes sure that forking executors basic execute works" do
+    test_file_name = "ForkingExecutorTestFile"
+    begin
+      forking_executor = ForkingExecutor.new
+      File.exists?(test_file_name).should == false
+      forking_executor.execute do
+        File.new(test_file_name, 'w')
+      end
+      sleep 3
+      File.exists?(test_file_name).should == true
+    ensure
+      File.unlink(test_file_name)
+    end
+  end
+
+  it "ensures that one worker for forking executor will only allow one thing to be processed at a time" do
+    executor = ForkingExecutor.new(:max_workers => 1)
+
+    test_file_name = "ForkingExecutorRunOne"
+    File.new(test_file_name, "w")
+    start_time = Time.now
+    executor.execute do
+      File.open(test_file_name, "a+") { |f| f.write("First Execution\n")}
+      sleep 4
+    end
+    # Because execute will block if the worker queue is full, we will wait here
+    # if we have reached the max number of workers
+    executor.execute { 2 + 2 }
+    finish_time = Time.now
+    # If we waited for the first task to finish, then we will have waited at
+    # least 4 seconds; if we didn't, we should not have waited. Thus, if we have
+    # waited > 3 seconds, we have likely waited for the first task to finish
+    # before doing the second one
+    (finish_time - start_time).should > 3
+    File.unlink(test_file_name)
+  end
+
+  it "ensures that you cannot execute more tasks on a shutdown executor" do
+    forking_executor = ForkingExecutor.new
+    forking_executor.execute {}
+    forking_executor.execute {}
+    forking_executor.shutdown(1)
+    expect { forking_executor.execute { "yay" } }.to raise_error RejectedExecutionException
+  end
+
+  context "#remove_completed_pids" do
+    class Status
+      def success?; true; end
+    end
+
+    context "with block=false" do
+      it "should not block if not child process available" do
+
+        # stub out Process.waitpid2 to return only 2 processes
+        allow(Process).to receive(:waitpid2).and_return(nil)
+        allow_any_instance_of(AWS::Flow::ForkingExecutor).to receive(:fork).and_return(1, 2, 3)
+        executor = ForkingExecutor.new(max_workers: 3)
+
+        executor.execute { sleep 1 }
+        executor.execute { sleep 1 }
+        executor.execute { sleep 1 }
+        executor.pids.size.should == 3
+        executor.send(:remove_completed_pids, false)
+        # The two processes that are completed will be reaped.
+        executor.pids.size.should == 3
+      end
+
+      it "should reap all completed child processes" do
+
+        allow(Process).to receive(:waitpid2).and_return([1, Status.new], [2, Status.new], [3, Status.new] )
+        allow_any_instance_of(AWS::Flow::ForkingExecutor).to receive(:fork).and_return(1, 2, 3)
+        executor = ForkingExecutor.new(max_workers: 3)
+
+        executor.execute { sleep 1 }
+        executor.execute { sleep 1 }
+        executor.execute { sleep 1 }
+        executor.pids.size.should == 3
+        executor.send(:remove_completed_pids, false)
+        # The two processes that are completed will be reaped.
+        executor.pids.size.should == 0
+      end
+    end
+    context "with block=true" do
+      it "should wait for atleast one child process to become available and then reap as many as possible" do
+
+        # stub out Process.waitpid2 to return only 2 processes
+        allow(Process).to receive(:waitpid2).and_return([1, Status.new], [2, Status.new], nil)
+        allow_any_instance_of(AWS::Flow::ForkingExecutor).to receive(:fork).and_return(1, 2, 3)
+        executor = ForkingExecutor.new(max_workers: 3)
+
+        executor.execute { sleep 1 }
+        executor.execute { sleep 1 }
+        executor.execute { sleep 5 }
+
+        executor.pids.size.should == 3
+
+        executor.send(:remove_completed_pids, true)
+        # It will wait for one of the processes to become available and then
+        # reap as many as possible
+        executor.pids.size.should == 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require_relative 'setup'
+
+describe FlowConstants do
+  options = {
+    :initial_retry_interval => 1,
+    :backoff_coefficient => 2,
+    :should_jitter => false,
+    :maximum_retry_interval_seconds => 100
+  }
+  options = ExponentialRetryOptions.new(options)
+
+  context "#default_exponential_retry_function" do
+
+    it "will test the default retry function with regular cases" do
+      time = Time.now
+      test_first = [time, time, time]
+      test_time_of_failure = [time, time+10, time+100]
+      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, options)
+        (result == output).should == true
+      end
+    end
+
+    it "will test for exceptions" do
+      expect { FlowConstants.exponential_retry_function.call(-1, nil, {}, options) }.to raise_error(ArgumentError, "first should be an instance of Time")
+      expect { FlowConstants.exponential_retry_function.call(Time.now, 0, {}, options) }.to raise_error(ArgumentError, "time_of_failure should be nil or an instance of Time")
+      expect { FlowConstants.exponential_retry_function.call(Time.now, nil, {Exception=>-1}, options) }.to raise_error(ArgumentError, "number of attempts should be positive")
+      expect { FlowConstants.exponential_retry_function.call(Time.now, nil, {Exception=>-1, ActivityTaskTimedOutException=>-10}, options) }.to raise_error(ArgumentError, "number of attempts should be positive")
+      expect { FlowConstants.exponential_retry_function.call(Time.now, nil, {Exception=>2, ActivityTaskTimedOutException=>-10}, options) }.to raise_error(ArgumentError, "number of attempts should be positive")
+    end
+
+    it "ensures the default retry function will use the user provided options" do
+      first = Time.now
+      time_of_failure = nil 
+      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
+
+  context "#default_jitter_function" do
+    it "ensures that the jitter function checks arguments passed to it" do
+      expect { FlowConstants.jitter_function.call(1, -1) }.to raise_error(
+        ArgumentError, "max_value should be greater than 0")
+    end
+    it "ensures that we get same jitter for a particular execution id" do
+      (FlowConstants.jitter_function.call(1, 100)).should equal(FlowConstants.jitter_function.call(1, 100))
+    end
+  end
+end
+

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

@@ -0,0 +1,101 @@
+require_relative 'setup'
+
+describe "Miscellaneous" do
+  it "ensures with_retry can be called without including AWS::Flow" do
+
+    class TestWorkflow
+      extend AWS::Flow::Workflows
+      workflow (:start) { {:version => "1"} }
+
+      def start
+        AWS::Flow::with_retry do
+          return "This is the entry point"
+        end
+      end
+    end
+
+    class SynchronousWorkflowTaskPoller < AWS::Flow::WorkflowTaskPoller
+      def get_decision_task
+        workflow_type = FakeWorkflowType.new(nil, "TestWorkflow.start", "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
+
+    workflow_type_object = double("workflow_type", :name => "TestWorkflow.start", :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::workflow_client(swf_client, domain) { { from_class: "TestWorkflow" } }
+    workflow_client.start_execution
+
+    workflow_worker.start
+  end
+
+  it "ensures decision_context can be called without including AWS::Flow" do
+
+    class TestWorkflow
+      extend AWS::Flow::Workflows
+      workflow (:start) { {:version => "1"} }
+
+      def start
+        return AWS::Flow::decision_context.workflow_clock.current_time
+      end
+    end
+
+    class SynchronousWorkflowTaskPoller < AWS::Flow::WorkflowTaskPoller
+      def get_decision_task
+        workflow_type = FakeWorkflowType.new(nil, "TestWorkflow.start", "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
+
+    workflow_type_object = double("workflow_type", :name => "TestWorkflow.start", :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::workflow_client(swf_client, domain) { { from_class: "TestWorkflow" } }
+    workflow_client.start_execution
+
+    workflow_worker.start
+  end
+
+  it "makes sure we can remove depedency on UUIDTools" do
+    class TestWorkflow
+      extend AWS::Flow::Workflows
+      workflow (:start) { { version: "1.0" } }
+      def start; end
+    end
+
+    require "securerandom"
+    # first check if SecureRandom.uuid returns uuid in the right format
+    regex = /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+    SecureRandom.uuid.should match(regex)
+
+    # Now check if the uuid is correctly set in start_external_workflow method
+    workflow_type = WorkflowType.new(nil, "TestWorkflow.start", "1")
+    client = AWS::Flow::WorkflowClient.new(FakeServiceClient.new, FakeDomain.new(workflow_type), TestWorkflow, WorkflowOptions.new)
+    workflow = client.start_execution
+    workflow.workflow_id.should match(regex)
+  end
+
+end
+
+

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

@@ -0,0 +1,289 @@
+require_relative 'setup'
+
+describe AWS::Flow::ActivityRegistrationOptions do
+  context "#get_registration_options" do
+
+    it "should return the default registration options if not value is passed in" do
+      options = AWS::Flow::ActivityRegistrationOptions.new
+      options.get_registration_options.should == { 
+        default_task_heartbeat_timeout: "NONE",
+        default_task_schedule_to_close_timeout: "NONE",
+        default_task_schedule_to_start_timeout: "NONE",
+        default_task_start_to_close_timeout: "NONE",
+        default_task_list: "USE_WORKER_TASK_LIST"
+      }
+    end
+
+    it "should return the new registration options if values are passed in" do
+      options = AWS::Flow::ActivityRegistrationOptions.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,
+        default_task_list: "test_tasklist",
+      })
+      options.get_registration_options.should == {
+        default_task_heartbeat_timeout: "5",
+        default_task_schedule_to_close_timeout: "50",
+        default_task_schedule_to_start_timeout: "20",
+        default_task_start_to_close_timeout: "30",
+        default_task_list: "test_tasklist"
+      }
+    end
+  end
+
+  context "#get_full_options" do
+
+    it "should contain both registration and regular options" do
+      options = AWS::Flow::ActivityRegistrationOptions.new
+      full_options = options.get_full_options
+      expected = {
+        default_task_heartbeat_timeout: "NONE",
+        default_task_schedule_to_close_timeout: "NONE",
+        default_task_schedule_to_start_timeout: "NONE",
+        default_task_start_to_close_timeout: "NONE",
+        default_task_list: "USE_WORKER_TASK_LIST",
+        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.delete(:data_converter) == expected.delete(:data_converter)
+      full_options.keys.sort.should == expected.keys.sort
+      full_options.values.sort.should == expected.values.sort
+    end
+
+    it "should return the values passed in" do
+      options = AWS::Flow::ActivityRegistrationOptions.new({
+        default_task_schedule_to_start_timeout: 20,
+        default_task_start_to_close_timeout: 30,
+        default_task_heartbeat_timeout: 5,
+        task_list: "test_tasklist",
+        version: "1.0",
+        prefix_name: "FooActivity",
+        manual_completion: true,
+        heartbeat_timeout: 10
+      })
+      full_options = options.get_full_options
+      expected = {
+        default_task_heartbeat_timeout: "5",
+        default_task_schedule_to_close_timeout: "NONE",
+        default_task_schedule_to_start_timeout: "20",
+        default_task_start_to_close_timeout: "30",
+        default_task_list: "USE_WORKER_TASK_LIST",
+        task_list: "test_tasklist",
+        version: "1.0",
+        prefix_name: "FooActivity",
+        manual_completion: true,
+        heartbeat_timeout: "10",
+        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
+      [:data_converter, :manual_completion].each { |x| full_options.delete(x).should == expected.delete(x) }
+      full_options.keys.sort.should == expected.keys.sort
+      full_options.values.sort.should == expected.values.sort
+    end
+
+  end
+
+end
+
+describe AWS::Flow::WorkflowRegistrationOptions do
+
+  context "#get_registration_options" do
+    
+    it "should return the default registration options if not value is passed in" do
+      options = AWS::Flow::WorkflowRegistrationOptions.new
+      options.get_registration_options.should == { 
+        default_task_start_to_close_timeout: "30",
+        default_child_policy: "TERMINATE",
+        default_task_list: "USE_WORKER_TASK_LIST"
+      }
+    end
+
+    it "should return the new registration options if values are passed in" do
+      options = AWS::Flow::WorkflowRegistrationOptions.new({
+        default_task_schedule_to_close_timeout: 30,
+        default_execution_start_to_close_timeout: 600,
+        default_child_policy: "ABANDON",
+        default_task_list: "task_list"
+      })
+      options.get_registration_options.should == {
+        default_task_start_to_close_timeout: "30",
+        default_execution_start_to_close_timeout: "600",
+        default_child_policy: "ABANDON",
+        default_task_list: "task_list"
+      }
+    end
+
+  end
+
+  context "#get_full_options" do
+
+    it "should not contain any registration options" do
+      options = AWS::Flow::WorkflowRegistrationOptions.new
+      full_options = options.get_full_options
+      expected = {
+        default_task_start_to_close_timeout: "30",
+        default_child_policy: "TERMINATE",
+        default_task_list: "USE_WORKER_TASK_LIST",
+        tag_list: [],
+        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
+      [:data_converter, :tag_list].each { |x| full_options.delete(x).should == expected.delete(x) }
+      full_options.keys.sort.should == expected.keys.sort
+      full_options.values.sort.should == expected.values.sort
+    end
+
+    it "should return the values passed in" do
+      options = AWS::Flow::WorkflowRegistrationOptions.new({
+        default_task_start_to_close_timeout: "30",
+        default_child_policy: "TERMINATE",
+        default_task_list: "USE_WORKER_TASK_LIST",
+        task_list: "test_tasklist",
+        version: "1.0",
+        prefix_name: "FooActivity",
+        tag_list: ["tag1", "tag2"]
+      })
+      full_options = options.get_full_options
+      expected = {
+        default_task_start_to_close_timeout: "30",
+        default_child_policy: "TERMINATE",
+        default_task_list: "USE_WORKER_TASK_LIST",
+        task_list: "test_tasklist",
+        version: "1.0",
+        prefix_name: "FooActivity",
+        data_converter: FlowConstants.default_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.keys.sort.should == expected.keys.sort
+      full_options.values.sort.should == expected.values.sort
+    end
+
+  end
+
+end
+
+describe AWS::Flow::ActivityOptions do
+
+  context "#get_full_options" 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
+    end
+
+    it "should return the values passed in" do
+      options = AWS::Flow::ActivityOptions.new({
+        task_list: "test_tasklist",
+        version: "1.0",
+        prefix_name: "FooActivity",
+        manual_completion: true,
+        heartbeat_timeout: 10
+      })
+      full_options = options.get_full_options
+      expected = {
+        task_list: "test_tasklist",
+        version: "1.0",
+        prefix_name: "FooActivity",
+        manual_completion: true,
+        heartbeat_timeout: "10",
+        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
+      [:data_converter, :manual_completion].each { |x| full_options.delete(x).should == expected.delete(x) }
+      full_options.keys.sort.should == expected.keys.sort
+      full_options.values.sort.should == expected.values.sort
+    end
+
+  end
+
+end
+describe AWS::Flow::WorkflowOptions do
+
+  context "#get_full_options" 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
+    end
+
+    it "should return the values passed in" do
+      options = AWS::Flow::WorkflowOptions.new({
+        task_list: "test_tasklist",
+        version: "1.0",
+        prefix_name: "FooWorkflow",
+        tag_list: ["tag1", "tag2"]
+      })
+      full_options = options.get_full_options
+      expected = {
+        task_list: "test_tasklist",
+        version: "1.0",
+        prefix_name: "FooWorkflow",
+        tag_list: ["tag1", "tag2"],
+        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
+      [:data_converter, :tag_list].each { |x| full_options.delete(x).should == expected.delete(x) }
+      full_options.keys.sort.should == expected.keys.sort
+      full_options.values.sort.should == expected.values.sort
+    end
+
+  end
+
+end
+
+describe AWS::Flow::WorkflowRegistrationDefaults do
+
+  context "#defaults" 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.default_task_start_to_close_timeout.should == 30
+      defaults.default_child_policy.should == "TERMINATE"
+      defaults.tag_list.should == []
+      defaults.default_task_list.should == AWS::Flow::FlowConstants.use_worker_task_list
+    end
+
+  end
+
+end
+
+describe AWS::Flow::ActivityRegistrationDefaults do
+
+  context "#defaults" 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.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
+      defaults.default_task_heartbeat_timeout.should == Float::INFINITY
+      defaults.default_task_list.should == AWS::Flow::FlowConstants.use_worker_task_list
+    end
+
+  end
+
+end
+