aws-flow 2.3.1 → 2.4.0

data/spec/aws/templates/unit/activity_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+include AWS::Flow::Templates
+
+describe ActivityTemplate do
+
+  context "#activity" do
+
+    it "creates an ActivityTemplate with correct name and options" do
+      template = activity("ActivityClass.my_activity")
+      template.should be_kind_of(ActivityTemplate)
+      template.name.should == "my_activity"
+      template.options[:prefix_name].should == "ActivityClass"
+    end
+
+  end
+
+  context "#initialize" do
+
+    it "assigns activity name and default options correctly" do
+      template = ActivityTemplate.new("ActivityClass.my_activity")
+      template.name.should == "my_activity"
+      template.options[:version].should == "1.0"
+      template.options[:prefix_name].should == "ActivityClass"
+      template.options[:data_converter].should be_kind_of(FlowConstants.data_converter.class)
+    end
+
+    it "raises if full activity name is not given" do
+      expect{ActivityTemplate.new("ActivityClass")}.to raise_error
+    end
+
+    it "ignores irrelevant activity options" do
+      options = {
+        foo: "asdf"
+      }
+      template = ActivityTemplate.new("ActivityClass.my_activity", options)
+      template.name.should == "my_activity"
+      template.options.should_not include(:foo)
+    end
+
+    it "overrides default options correctly" do
+      options = {
+        exponential_retry: {
+          maximum_attempts: 3
+        },
+        version: "2.0",
+        task_list: "foo_tasklist"
+      }
+      template = ActivityTemplate.new("ActivityClass.my_activity", options)
+      template.name.should == "my_activity"
+      template.options[:version].should == "2.0"
+      template.options[:task_list].should == "foo_tasklist"
+      template.options[:exponential_retry].should == { maximum_attempts: 3 }
+
+      template.options[:prefix_name].should == "ActivityClass"
+      template.options[:data_converter].should be_kind_of(FlowConstants.data_converter.class)
+    end
+
+  end
+
+  context "#run" do
+
+    it "ensures run method calls the context" do
+      template = activity("ActivityClass.my_activity")
+      input = { input: "foo" }
+
+      context = double
+      expect(context).to receive(:act_client).and_return(context)
+      expect(context).to receive(:my_activity).with(input)
+
+      template.run(input, context)
+    end
+
+    it "ensures activity is scheduled on the correct tasklist" do
+      template = activity("ActivityClass.my_activity")
+      input = { input: "foo", task_list: "bar" }
+
+      context = double
+      expect(context).to receive(:act_client).and_return(context)
+      expect(context).to receive(:my_activity).with(input)
+      # Couldn't find a better way to test this because internally the options
+      # hash is wrapped in a block and passed to the activity client.
+      expect_any_instance_of(Hash).to receive(:merge!).with({task_list: "bar"})
+
+      template.run(input, context)
+    end
+
+  end
+
+end

data/spec/aws/templates/unit/base_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+include AWS::Flow::Templates
+
+describe RootTemplate do
+
+  context "#root" do
+
+    it "initializes the RootTemplate with correct step and result_step" do
+      template = root("foo")
+      template.should be_kind_of(RootTemplate)
+      template.step.should == "foo"
+      template.result_step.should be_nil
+
+      template = root("foo", "bar")
+      template.should be_kind_of(RootTemplate)
+      template.step.should == "foo"
+      template.result_step.should == "bar"
+    end
+
+  end
+
+  context "#run" do
+
+    let(:step) { double }
+    let(:result_step) { double }
+
+    it "runs the step" do
+      expect(step).to receive(:run).with("input", "context")
+      template = root(step)
+      template.run("input", "context")
+    end
+
+    it "returns the result if result_step is nil" do
+      expect(step).to receive(:run).with("input", "context").and_return("result")
+      expect(result_step).not_to receive(:run)
+
+      template = root(step)
+      template.run("input", "context").should == "result"
+    end
+
+    it "calls the result_step if result_step is not nil" do
+      expect(step).to receive(:run).with("input", "context").and_return("result")
+      expect(result_step).to receive(:run).with("result", "context")
+
+      template = root(step, result_step)
+      template.run("input", "context").should == "result"
+   end
+
+    it "catches exceptions and calls result_step if result_step is not nil" do
+      expect(step).to receive(:run).with("input", "context") do
+        raise "test"
+      end
+      expect(result_step).to receive(:run) do |input, context|
+        input.should include(:failure)
+        input[:failure].should be_kind_of(RuntimeError)
+        context.should == "context"
+      end
+
+      expect { root(step, result_step).run("input", "context") }.to raise_error
+    end
+
+    it "catches exceptions and doesn't call result_step if result_step is nil" do
+      expect(step).to receive(:run).with("input", "context") do
+        raise "test"
+      end
+      expect(result_step).not_to receive(:run)
+      expect { root(step, result_step).run("input", "context") }.to raise_error
+    end
+
+  end
+
+end

data/spec/aws/templates/unit/default_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe Templates do
+
+  context "#default_workflow" do
+
+    let(:klass) { AWS::Flow::Templates.default_workflow}
+
+    it "correctly creates a Ruby Flow default workflow" do
+      klass.should be_kind_of(AWS::Flow::Workflows)
+      klass.workflows.size.should == 1
+      klass.workflows.first.name.should == "#{FlowConstants.defaults[:prefix_name]}"\
+        ".#{FlowConstants.defaults[:execution_method]}"
+      klass.workflows.first.version.should == FlowConstants.defaults[:version]
+    end
+
+    it "creates the necessary workflow and client methods" do
+      klass.instance_methods(false).should include(:act_client)
+      klass.instance_methods(false).should include(:child_client)
+      klass.instance_methods(false).should include(:start)
+    end
+
+    it "sets workflow options correctly" do
+      options = klass.workflows.first.options
+      options.execution_method.should == FlowConstants.defaults[:execution_method]
+      options.prefix_name.should == FlowConstants.defaults[:prefix_name]
+      options.version.should == FlowConstants.defaults[:version]
+    end
+
+    it "doesn't throw an exception if a default workflow already exists" do
+      expect{AWS::Flow::Templates.default_workflow}.not_to raise_error
+    end
+
+    context "#start" do
+
+      let(:obj) { klass.new }
+
+      it "checks workflow input correctly" do
+        expect{obj.start("some_input")}.to raise_error(ArgumentError)
+        expect{obj.start(args: "some_input")}.to raise_error(ArgumentError)
+        expect{obj.start(definition: "some_input")}.to raise_error(ArgumentError)
+      end
+
+      it "runs template correctly" do
+        template = double
+        expect(template).to receive(:run).with({input: "some_input"}, an_instance_of(klass))
+        expect(template).to receive(:is_a?).and_return(true)
+        expect{obj.start(
+          args: {input: "some_input"},
+          definition: template
+        )}.not_to raise_error
+      end
+
+    end
+  end
+
+  context "#make_activity_class" do
+
+    before(:all) do
+      class FooClass
+        def foo; end
+        def bar; end
+      end
+    end
+
+    it "returns input as-is if it is nil" do
+      AWS::Flow::Templates.make_activity_class(nil).should be_nil
+    end
+
+    it "correctly creates a proxy Activity class" do
+      klass = AWS::Flow::Templates.make_activity_class(FooClass)
+      klass.should be_kind_of(AWS::Flow::Activities)
+      klass.should == AWS::Flow::Templates::ActivityProxies.const_get("FooClassProxy")
+      klass.new.instance.should be_kind_of(FooClass)
+      activities = klass.activities.map(&:name).map { |x| x.split('.').last.to_sym }
+      activities.should include(*FooClass.instance_methods(false))
+    end
+
+    it "correctly converts the ruby class contained in a module into an Activity class" do
+      Object.const_set("FooModule", Module.new)
+      klass = FooModule.const_set("FooClass1", Class.new(Object))
+      klass = AWS::Flow::Templates.make_activity_class(klass)
+      klass.should be_kind_of(AWS::Flow::Activities)
+      klass.should == AWS::Flow::Templates::ActivityProxies.const_get("FooClass1Proxy")
+    end
+
+    it "correctly converts instance methods to activities and assigns options" do
+      klass = Object.const_set("BarClass", Class.new(Object) { def foo_method; end })
+      klass = AWS::Flow::Templates.make_activity_class(klass)
+      klass.activities.first.name.should == "BarClass.foo_method"
+      opts = klass.activities.first.options
+      opts.version.should == "1.0"
+      opts.prefix_name.should == "BarClass"
+
+      Object.const_set("FooModule1", Module.new)
+      klass = FooModule1.const_set("FooClass2", Class.new(Object) { def foo_method; end })
+      klass = AWS::Flow::Templates.make_activity_class(klass)
+      klass.activities.first.name.should == "FooClass2.foo_method"
+      opts = klass.activities.first.options
+      opts.version.should == "1.0"
+      opts.prefix_name.should == "FooClass2"
+    end
+
+    it "passes the messages to the proxy instance methods" do
+      klass = AWS::Flow::Templates.make_activity_class(FooClass)
+      expect_any_instance_of(FooClass).to receive(:foo)
+      expect_any_instance_of(FooClass).to receive(:bar)
+      klass.new.foo
+      klass.new.bar
+    end
+
+  end
+
+  context "#result_activity" do
+
+    let(:klass) { AWS::Flow::Templates.result_activity }
+
+    it "correctly returns the FlowDefaultResultActivityRuby class" do
+      klass.should be_kind_of(AWS::Flow::Activities)
+      klass.activities.size.should == 1
+      klass.name.should == "AWS::Flow::Templates::FlowDefaultResultActivityRuby"
+      klass.activities.first.name.should == "#{FlowConstants.defaults[:result_activity_prefix]}"\
+        ".#{FlowConstants.defaults[:result_activity_method]}"
+      klass.activities.first.version.should == FlowConstants.defaults[:version]
+      klass.instance_methods(false).should include(:result)
+    end
+
+    it "correctly initializes and sets the result" do
+      inst = klass.new
+      expect(inst.result).to be_kind_of(AWS::Flow::Core::Future)
+      inst.run("foo")
+      inst.result.get.should == "foo"
+    end
+
+    it "doesn't throw an exception if a default activity class already exists" do
+      expect{AWS::Flow::Templates.result_activity}.not_to raise_error
+    end
+
+  end
+
+end

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

@@ -0,0 +1,271 @@
+require 'spec_helper'
+
+describe "AWS::Flow::Templates" do
+
+  context "#start" do
+
+    it "starts activity invocation with default options" do
+
+      # Check all options being passed in
+      expect(AWS::Flow).to receive(:start_workflow) do |input, options|
+        input.should include(:definition)
+        input[:definition].should be_kind_of(AWS::Flow::Templates::RootTemplate)
+        activity = input[:definition].step
+        activity.should be_kind_of(AWS::Flow::Templates::ActivityTemplate)
+        activity.name.should == "hello"
+        activity.options.should include(
+          version: FlowConstants.defaults[:version],
+          prefix_name: "HelloWorld",
+        )
+        input[:definition].result_step.should be_nil
+
+        activity.options[:data_converter].should be_kind_of(FlowConstants.data_converter.class)
+
+        input.should include(:args)
+        input[:args].should include(:foo)
+
+        options.should include(
+          domain: FlowConstants.defaults[:domain],
+          prefix_name: FlowConstants.defaults[:prefix_name],
+          execution_method: FlowConstants.defaults[:execution_method],
+          version: FlowConstants.defaults[:version],
+          execution_start_to_close_timeout: FlowConstants.defaults[:execution_start_to_close_timeout],
+          task_list: FlowConstants.defaults[:task_list],
+          # Check if the tags are set correctly
+          tag_list: ["HelloWorld.hello"]
+        )
+        options[:data_converter].should be_kind_of(FlowConstants.data_converter.class)
+
+      end
+      AWS::Flow::start("HelloWorld.hello", {foo: "Foo"})
+
+    end
+
+    it "starts activity invocation with overriden options" do
+
+      expect(AWS::Flow).to receive(:start_workflow) do |input, options|
+
+        activity = input[:definition].step
+        # Check if the activity got the correct options
+        activity.options.should include(
+          version: "2.0",
+          prefix_name: "HelloWorld",
+          exponential_retry: {
+            maximum_attempts: 10
+          }
+        )
+
+        activity.options[:data_converter].should be_kind_of(FlowConstants.data_converter.class)
+
+        options.should include(
+          prefix_name: FlowConstants.defaults[:prefix_name],
+          execution_method: FlowConstants.defaults[:execution_method],
+          version: FlowConstants.defaults[:version],
+          domain: FlowConstants.defaults[:domain],
+          execution_start_to_close_timeout: 120,
+          # Check if the tags are set correctly
+          tag_list: ["HelloWorld.hello"]
+        )
+
+        options[:data_converter].should be_kind_of(FlowConstants.data_converter.class)
+
+      end
+
+      options = {
+        execution_start_to_close_timeout: 120,
+        version: "2.0",
+        exponential_retry: { maximum_attempts: 10 }
+      }
+
+      AWS::Flow::start("HelloWorld.hello", {input: "input"}, options)
+
+    end
+
+    it "doesn't muddle activity and workflow options" do
+
+      expect(AWS::Flow).to receive(:start_workflow) do |input, options|
+
+        activity = input[:definition].step
+        # Check if the activity got the correct options
+        activity.options.should include(
+          version: "2.0",
+          prefix_name: "HelloWorld",
+          start_to_close_timeout: 10,
+          data_converter: "Foo",
+          exponential_retry: {
+            maximum_attempts: 10
+          }
+        )
+
+        options.should include(
+          prefix_name: FlowConstants.defaults[:prefix_name],
+          execution_method: FlowConstants.defaults[:execution_method],
+          version: FlowConstants.defaults[:version],
+          domain: FlowConstants.defaults[:domain],
+          execution_start_to_close_timeout: 120,
+          # Check if the tags are set correctly
+          tag_list: ["HelloWorld.hello"],
+          data_converter: "Foo"
+        )
+
+      end
+
+      options = {
+        start_to_close_timeout: 10,
+        execution_start_to_close_timeout: 120,
+        version: "2.0",
+        exponential_retry: { maximum_attempts: 10 },
+        child_policy: "TERMINATE",
+        data_converter: "Foo"
+      }
+
+      AWS::Flow::start("HelloWorld.hello", {input: "input"}, options)
+
+    end
+
+    it "doesn't initialize result_step when wait is false" do
+
+      expect(AWS::Flow).to receive(:start_workflow) do |input, options|
+        input[:definition].result_step.should be_nil
+      end
+
+      options = {
+        wait: false
+      }
+
+      AWS::Flow::start("HelloWorld.hello", {input: "input"}, options)
+
+    end
+
+    it "initializes result_step and calls get_result when wait is true" do
+
+      expect(AWS::Flow).to receive(:start_workflow) do |input, options|
+        input[:definition].result_step.should_not be_nil
+      end
+
+      expect(AWS::Flow::Templates).to receive(:get_result)
+
+      options = {
+        wait: true
+      }
+
+      AWS::Flow::start("HelloWorld.hello", {input: "input"}, options)
+
+    end
+
+    it "calls get_result with timeout value when wait & wait_timeout are set" do
+
+      expect(AWS::Flow).to receive(:start_workflow) do |input, options|
+        input[:definition].result_step.should_not be_nil
+      end
+
+      expect(AWS::Flow::Templates).to receive(:get_result) do |tasklist, domain, timeout|
+        timeout.should == 10
+      end
+
+      options = {
+        wait: true,
+        wait_timeout: 10
+      }
+
+      AWS::Flow::start("HelloWorld.hello", {input: "input"}, options)
+
+    end
+
+
+  end
+
+  context "#get_result" do
+
+    it "starts an activity worker and sets the future" do
+
+      tasklist = "result_tasklist: foo"
+
+      # Get the result activity class
+      klass = AWS::Flow::Templates.result_activity
+      instance = klass.new
+
+      expect(klass).to receive(:new).and_return(instance)
+
+      expect_any_instance_of(AWS::Flow::ActivityWorker).to receive(:add_implementation) do |k|
+        k.class.should == AWS::Flow::Templates.const_get("#{FlowConstants.defaults[:result_activity_prefix]}")
+        k.result.should be_kind_of(AWS::Flow::Core::Future)
+      end
+
+      expect_any_instance_of(AWS::Flow::ActivityWorker).to receive(:run_once) do
+        # Manually call the activity
+        instance.send(FlowConstants.defaults[:result_activity_method].to_sym, {name: "foo"} )
+      end
+
+      # Call get_result and check that the result is set
+      result = AWS::Flow::Templates.get_result(tasklist, "domain")
+
+      result.should include(name: "foo")
+
+    end
+
+    it "times out correctly" do
+
+      tasklist = "result_tasklist: foo"
+
+      # Get the result activity class
+      klass = AWS::Flow::Templates.result_activity
+      instance = klass.new
+
+      expect(klass).to receive(:new).and_return(instance)
+
+      expect_any_instance_of(AWS::Flow::ActivityWorker).to receive(:run_once) do
+        # Manually call the activity
+        sleep 5
+        instance.send(FlowConstants.defaults[:result_activity_method].to_sym, {name: "foo"} )
+      end
+
+      # Call get_result and check that the result is set
+      result = AWS::Flow::Templates.get_result(tasklist, "domain", 1)
+      result.should be_nil
+
+    end
+
+
+  end
+
+  context "#register_default_domain" do
+
+    it "registers the default domain" do
+      expect(AWS::Flow::Utilities).to receive(:register_domain) do |name|
+        name.should == FlowConstants.defaults[:domain]
+      end
+      AWS::Flow::Templates.register_default_domain
+    end
+
+  end
+
+  context "#register_default_workflow" do
+
+    it "registers the default workflow" do
+      domain = double
+      allow(domain).to receive(:client).and_return(domain)
+      expect_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:add_implementation) do |k|
+        k.should == AWS::Flow::Templates.const_get("#{FlowConstants.defaults[:prefix_name]}")
+      end
+      expect_any_instance_of(AWS::Flow::WorkflowWorker).to receive(:register)
+      AWS::Flow::Templates.register_default_workflow(domain)
+    end
+
+  end
+
+  context "#register_default_result_activity" do
+
+    it "registers the default result activity" do
+      domain = double
+      allow(domain).to receive(:client).and_return(domain)
+      expect_any_instance_of(AWS::Flow::ActivityWorker).to receive(:add_implementation) do |k|
+        k.should == AWS::Flow::Templates.const_get("#{FlowConstants.defaults[:result_activity_prefix]}")
+      end
+      expect_any_instance_of(AWS::Flow::ActivityWorker).to receive(:register)
+      AWS::Flow::Templates.register_default_result_activity(domain)
+    end
+
+  end
+
+end