aws-flow 2.4.0 → 3.0.0

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

@@ -6,6 +6,7 @@ include Test::Integ
 describe "Runner" do
   before(:all) do
     @swf, @domain = setup_swf
+    kill_executors
   end
 
   class PingUtils

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

@@ -333,7 +333,7 @@ describe "Runner" do
       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)
+      AWS::Flow::Templates::Utils.stub(:register_default_result_activity)
 
       # what we are testing:
       expect(AWS::Flow::Runner).to receive(:fork).exactly(3).times
@@ -352,7 +352,7 @@ describe "Runner" do
       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)
+      AWS::Flow::Templates::Utils.stub(:register_default_result_activity)
 
       # what we are testing:
       expect(AWS::Flow::Runner).to receive(:fork).exactly(0).times
@@ -373,7 +373,7 @@ describe "Runner" do
 
       AWS::Flow::Runner.stub(:setup_domain)
       AWS::Flow::Runner.stub(:load_files)
-      AWS::Flow::Templates.stub(:register_default_result_activity)
+      AWS::Flow::Templates::Utils.stub(:register_default_result_activity)
 
       # what we are testing:
       expect(AWS::Flow::Runner).to receive(:fork).exactly(6).times

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

@@ -1,13 +1,12 @@
 require 'spec_helper'
-include AWS::Flow::Templates
 
-describe ActivityTemplate do
+describe AWS::Flow::Templates::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 = AWS::Flow::Templates::activity("ActivityClass.my_activity")
+      template.should be_kind_of(AWS::Flow::Templates::ActivityTemplate)
       template.name.should == "my_activity"
       template.options[:prefix_name].should == "ActivityClass"
     end
@@ -17,7 +16,7 @@ describe ActivityTemplate do
   context "#initialize" do
 
     it "assigns activity name and default options correctly" do
-      template = ActivityTemplate.new("ActivityClass.my_activity")
+      template = AWS::Flow::Templates::ActivityTemplate.new("ActivityClass.my_activity")
       template.name.should == "my_activity"
       template.options[:version].should == "1.0"
       template.options[:prefix_name].should == "ActivityClass"
@@ -25,14 +24,14 @@ describe ActivityTemplate do
     end
 
     it "raises if full activity name is not given" do
-      expect{ActivityTemplate.new("ActivityClass")}.to raise_error
+      expect{AWS::Flow::Templates::ActivityTemplate.new("ActivityClass")}.to raise_error
     end
 
     it "ignores irrelevant activity options" do
       options = {
         foo: "asdf"
       }
-      template = ActivityTemplate.new("ActivityClass.my_activity", options)
+      template = AWS::Flow::Templates::ActivityTemplate.new("ActivityClass.my_activity", options)
       template.name.should == "my_activity"
       template.options.should_not include(:foo)
     end
@@ -45,7 +44,7 @@ describe ActivityTemplate do
         version: "2.0",
         task_list: "foo_tasklist"
       }
-      template = ActivityTemplate.new("ActivityClass.my_activity", options)
+      template = AWS::Flow::Templates::ActivityTemplate.new("ActivityClass.my_activity", options)
       template.name.should == "my_activity"
       template.options[:version].should == "2.0"
       template.options[:task_list].should == "foo_tasklist"
@@ -60,7 +59,7 @@ describe ActivityTemplate do
   context "#run" do
 
     it "ensures run method calls the context" do
-      template = activity("ActivityClass.my_activity")
+      template = AWS::Flow::Templates::activity("ActivityClass.my_activity")
       input = { input: "foo" }
 
       context = double
@@ -71,7 +70,7 @@ describe ActivityTemplate do
     end
 
     it "ensures activity is scheduled on the correct tasklist" do
-      template = activity("ActivityClass.my_activity")
+      template = AWS::Flow::Templates::activity("ActivityClass.my_activity")
       input = { input: "foo", task_list: "bar" }
 
       context = double

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

@@ -1,18 +1,17 @@
 require 'spec_helper'
-include AWS::Flow::Templates
 
-describe RootTemplate do
+describe AWS::Flow::Templates::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 = AWS::Flow::Templates.root("foo")
+      template.should be_kind_of(AWS::Flow::Templates::RootTemplate)
       template.step.should == "foo"
       template.result_step.should be_nil
 
-      template = root("foo", "bar")
-      template.should be_kind_of(RootTemplate)
+      template = AWS::Flow::Templates.root("foo", "bar")
+      template.should be_kind_of(AWS::Flow::Templates::RootTemplate)
       template.step.should == "foo"
       template.result_step.should == "bar"
     end
@@ -26,7 +25,7 @@ describe RootTemplate do
 
     it "runs the step" do
       expect(step).to receive(:run).with("input", "context")
-      template = root(step)
+      template = AWS::Flow::Templates.root(step)
       template.run("input", "context")
     end
 
@@ -34,7 +33,7 @@ describe RootTemplate do
       expect(step).to receive(:run).with("input", "context").and_return("result")
       expect(result_step).not_to receive(:run)
 
-      template = root(step)
+      template = AWS::Flow::Templates.root(step)
       template.run("input", "context").should == "result"
     end
 
@@ -42,7 +41,7 @@ describe RootTemplate 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 = AWS::Flow::Templates.root(step, result_step)
       template.run("input", "context").should == "result"
    end
 
@@ -56,7 +55,7 @@ describe RootTemplate do
         context.should == "context"
       end
 
-      expect { root(step, result_step).run("input", "context") }.to raise_error
+      expect { AWS::Flow::Templates.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
@@ -64,7 +63,7 @@ describe RootTemplate do
         raise "test"
       end
       expect(result_step).not_to receive(:run)
-      expect { root(step, result_step).run("input", "context") }.to raise_error
+      expect { AWS::Flow::Templates.root(step, result_step).run("input", "context") }.to raise_error
     end
 
   end

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

@@ -122,14 +122,31 @@ describe Templates do
       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)
+      klass.instance_methods(false).should include(:run)
     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"
+    context "#run" do
+      let(:inst) { klass.new }
+      let(:result) { { key: "123", result: "asdf" } }
+
+      it "raises if key or result is not present" do
+        expect{inst.run("adsf")}.to raise_error(ArgumentError)
+      end
+
+      it "passes if key and result are present" do
+        expect{inst.run(result)}.not_to raise_error
+      end
+
+      it "uses the writer to send marshalled result" do
+        writer = double
+
+        expect(writer).to receive(:puts) do |x|
+          Marshal.load(x).should == result
+        end
+
+        inst = klass.new(writer)
+        inst.run(result)
+      end
     end
 
     it "doesn't throw an exception if a default activity class already exists" do

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

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe AWS::Flow::Templates::ResultWorker do
+
+  context "#semaphore" do
+
+    it "is a class instance variable" do
+      semaphore = AWS::Flow::Templates::ResultWorker.instance_variable_get("@semaphore")
+      semaphore.is_a?(Mutex)
+    end
+
+  end
+
+  context "#start" do
+
+    it "ensure that ResultWorker is started only once per process" do
+
+      AWS::Flow::Templates::ResultWorker.stub(:start_executor)
+      AWS::Flow::Templates::ResultWorker.start("domain")
+
+      task_list = AWS::Flow::Templates::ResultWorker.instance_variable_get("@task_list")
+      results = AWS::Flow::Templates::ResultWorker.instance_variable_get("@results")
+      executor = AWS::Flow::Templates::ResultWorker.instance_variable_get("@executor")
+
+      AWS::Flow::Templates::ResultWorker.start("domain")
+      AWS::Flow::Templates::ResultWorker.instance_variable_get("@task_list").should == task_list
+      AWS::Flow::Templates::ResultWorker.instance_variable_get("@results").should == results
+      AWS::Flow::Templates::ResultWorker.instance_variable_get("@executor").should == executor
+
+      AWS::Flow::Templates::ResultWorker.stop
+    end
+
+  end
+
+  context "#shutdown" do
+
+    it "tests clean exit of result worker" do
+      AWS::Flow::Templates::ResultWorker.start("FlowDefault")
+      sleep 1
+      Thread.list.count.should == 2
+      AWS::Flow::Templates::ResultWorker.stop
+      Thread.list.count.should == 1
+      AWS::Flow::Templates::ResultWorker.instance_variable_get("@executor").should be_nil
+    end
+
+  end
+
+  context "#start_listener" do
+
+    it "starts the listener thread and correctly sets the futures" do
+
+      class AWS::Flow::Templates::ResultWorker
+        class << self
+          alias_method :start_copy, :start
+          def start
+            @results = SynchronizedHash.new
+            self.init
+            @listener_t = nil
+          end
+        end
+      end
+
+      AWS::Flow::Templates::ResultWorker.start
+
+      AWS::Flow::Templates::ResultWorker.results[:key1] = ExternalFuture.new
+      AWS::Flow::Templates::ResultWorker.results[:key2] = ExternalFuture.new
+      AWS::Flow::Templates::ResultWorker.results[:key3] = ExternalFuture.new
+
+      reader, writer = IO.pipe
+
+      AWS::Flow::Templates::ResultWorker.start_listener(reader)
+      writer.puts Marshal.dump({key: :key1, result: "result1"})
+      writer.puts Marshal.dump({key: :key2, result: "result2"})
+      writer.puts Marshal.dump({key: :key3, result: "result3"})
+
+      AWS::Flow::Templates::ResultWorker.results[:key1].get.should == "result1"
+      AWS::Flow::Templates::ResultWorker.results[:key2].get.should == "result2"
+      AWS::Flow::Templates::ResultWorker.results[:key3].get.should == "result3"
+
+      writer.close
+      reader.close
+
+      class AWS::Flow::Templates::ResultWorker
+        class << self
+          alias_method :start_copy, :start
+        end
+      end
+
+    end
+
+  end
+
+  context "#get_result_future" do
+
+    it "returns a future and the future is removed from the hash when it is set" do
+
+      class AWS::Flow::Templates::ResultWorker
+        class << self
+          alias_method :start_copy, :start
+          def start
+            @results = SynchronizedHash.new
+          end
+        end
+      end
+
+      key = "foo"
+      future = ExternalFuture.new
+
+      AWS::Flow::Templates::ResultWorker.results[key] = future
+
+      # Call get_result and check that the result is set
+      result = AWS::Flow::Templates::ResultWorker.get_result_future(key)
+
+      result.should == future
+
+      future.set(nil)
+
+      AWS::Flow::Templates::ResultWorker.results[key].should be_nil
+
+      class AWS::Flow::Templates::ResultWorker
+        class << self
+          alias_method :start_copy, :start
+        end
+      end
+
+    end
+
+  end
+
+end

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

@@ -123,147 +123,74 @@ describe "AWS::Flow::Templates" do
 
     end
 
-    it "doesn't initialize result_step when wait is false" do
+    it "doesn't initialize result_step when get_result 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)
+      expect(AWS::Flow::Templates::ResultWorker).to_not receive(:start)
+      expect(AWS::Flow::Templates::ResultWorker).to_not receive(:get_result_future)
+      expect(AWS::Flow::Templates::Starter).to_not receive(:set_result_activity)
 
       options = {
-        wait: true
+        get_result: false
       }
 
       AWS::Flow::start("HelloWorld.hello", {input: "input"}, options)
 
     end
 
-    it "calls get_result with timeout value when wait & wait_timeout are set" do
+    it "initializes result_step and calls get_result when get_result 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) do |tasklist, domain, timeout|
-        timeout.should == 10
-      end
+      expect(AWS::Flow::Templates::ResultWorker).to receive(:start)
+      expect(AWS::Flow::Templates::ResultWorker).to receive(:get_result_future)
+      expect(AWS::Flow::Templates::Starter).to receive(:set_result_activity)
 
       options = {
-        wait: true,
-        wait_timeout: 10
+        get_result: true
       }
 
       AWS::Flow::start("HelloWorld.hello", {input: "input"}, options)
 
     end
 
-
   end
 
-  context "#get_result" do
-
-    it "starts an activity worker and sets the future" do
+  context "#set_result_activity" do
 
-      tasklist = "result_tasklist: foo"
+    it "sets the result step correctly and creates a new ExternalFuture" do
+      root = double
 
-      # 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)
+      class AWS::Flow::Templates::ResultWorker
+        class << self
+          alias_method :start_copy, :start
+          def start
+            @results = SynchronizedHash.new
+          end
+        end
       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
+      AWS::Flow::Templates::ResultWorker.start
 
-      # Call get_result and check that the result is set
-      result = AWS::Flow::Templates.get_result(tasklist, "domain")
+      expect(SecureRandom).to receive(:uuid).and_return("foo")
 
-      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"} )
+      expect(root).to receive(:result_step=) do |x|
+        x.is_a?(AWS::Flow::Templates::ResultActivityTemplate)
       end
 
-      # Call get_result and check that the result is set
-      result = AWS::Flow::Templates.get_result(tasklist, "domain", 1)
-      result.should be_nil
+      AWS::Flow::Templates::Starter.set_result_activity("task_list", root)
 
-    end
+      result = AWS::Flow::Templates::ResultWorker.results["result_key: foo"]
+      result.should_not be_nil
+      result.should be_a(AWS::Flow::Core::ExternalFuture)
 
-
-  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]
+      class AWS::Flow::Templates::ResultWorker
+        class << self
+          alias_method :start_copy, :start
+        end
       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