aws-flow-core 1.0.0

data/test/aws/flow_spec.rb

@@ -0,0 +1,255 @@
+##
+# 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 'pp'
+
+# TODO Split out fibers-related tests into a fibers_spec and
+# put the interface-related tests into something like interface_spec
+# Or maybe they can stay in flow_spec
+
+
+# Doesn't make sense to have this for daemon tasks, as the BRE will close before
+# it raises
+
+{:DaemonTask => lambda { |&x| daemon_task(&x) },
+  :Task => lambda { |&x| task(&x) } }.each_pair do |name, task_creation|
+
+
+
+
+  describe "#{name} method" do
+    let(:condition) { FiberConditionVariable.new }
+    # TODO Reinstate this test once we figure out how to fix Fibers in 1.8 sharing state
+
+    it "fails when called from outside of a context" do
+      expect do
+        task_creation.call do
+          "Invalid call"
+        end
+      end.to raise_error(NoContextException)
+    end
+
+    it "should execute #{name} children recursively"do
+      @executed = []
+      def recursive(i, task_creation)
+        return if i == 0
+        task_creation.call do
+          recursive(i - 1, task_creation)
+          @executed << i
+        end
+      end
+      scope = AsyncScope.new do
+        task { condition.wait }
+        recursive(100, task_creation)
+      end
+      @executed.length.should == 0
+      scope.eventLoop
+      @executed.length.should == 100
+    end
+
+
+
+    context 'tests that #{name} do things in the right order' do
+      let(:trace) { [] }
+      let(:condition) { FiberConditionVariable.new }
+      it "executes the block asynchronously" do
+        trace << :outside_task
+        scope = AsyncScope.new do
+          task_creation.call { trace << :inside_task; condition.signal }
+          task { condition.wait }
+        end
+        scope.eventLoop
+        trace.should == [:outside_task, :inside_task]
+      end
+
+      it "returns something which contains the block's return value" do
+        result = nil
+        scope = AsyncScope.new do
+          result = task_creation.call { condition.signal; :task_executed }
+          task { condition.wait }
+        end
+        scope.eventLoop
+        result.get.should == :task_executed
+      end
+
+      it "executes multiple #{name}s in order" do
+        scope = AsyncScope.new do
+          task_creation.call { trace << :first_task }
+          task_creation.call { trace << :second_task; condition.signal }
+          task { condition.wait }
+        end
+        scope.eventLoop
+        trace.should == [:first_task, :second_task]
+      end
+
+      it "executes nested #{name} after the parent task" do
+
+        scope = AsyncScope.new do
+          task_creation.call do
+            task_creation.call { trace << :inside_task; condition.signal }
+            trace << :outside_task
+          end
+          task { condition.wait }
+        end
+        scope.eventLoop
+        trace.should == [:outside_task, :inside_task]
+      end
+
+      it "executes nested #{name}" do
+        scope = AsyncScope.new do
+          task_creation.call do
+            trace << :outside_task
+            task_creation.call { trace << :inside_task; condition.signal }
+          end
+          task { condition.wait }
+        end
+        scope.eventLoop
+        trace.should == [:outside_task, :inside_task]
+      end
+    end
+  end
+end
+{:Task => lambda { |x, &y| Task.new(x, &y) },
+  :DaemonTask => lambda { |x, &y| DaemonTask.new(x, &y) }}.each_pair do |name, task_creation|
+
+  describe name do
+    let(:trace) { [] }
+    let(:scope) { AsyncScope.new }
+    let(:task) { task_creation.call(scope.root_context) { trace << :inner } }
+
+    context "result for a task that is not run" do
+      let(:result) { task.result }
+      subject { result }
+      its(:class) { should == Future }
+      it { should_not be_set }
+    end
+
+    it "executes a block asynchronously" do
+      trace << :outer
+      task.resume
+      trace.should == [:outer, :inner]
+    end
+
+    it "is the currently running Fiber when the block executes" do
+      task = task_creation.call(scope.root_context) do
+        fiber = ::Fiber.current
+        fiber.should == task
+        trace << :executed
+      end
+      task.resume
+      trace.should == [:executed]
+    end
+    it "doesn't let the block return from the block's parent method" do
+      def create_and_run_task(task_creation)
+        t = task_creation.call(scope.root_context) { return :inner_return }
+        t.resume
+        :outer_return
+      end
+      result = create_and_run_task(task_creation)
+      result.should == :outer_return
+    end
+
+    # context "cancelled Task" do
+    #   it "makes sure that a cancelled task does not run" do
+    #     task = task_creation.call(scope.root_context) { trace << :should_never_happen }
+    #     scope << task
+    #     task.cancel(StandardError)
+
+    #     trace.should == []
+    #   end
+    # end
+
+    context "Dead Fiber" do
+      let(:dead_task) { t = task_creation.call(scope.root_context) { 1 + 1 }; t.resume; t }
+      subject { dead_task }
+      it { should_not be_alive }
+      it "should raise FiberError on resume" do
+        expect { dead_task.resume }.to raise_error FiberError
+      end
+    end
+
+    it "makes sure that tasks return a Future" do
+      a = task_creation.call(scope.root_context) { trace << :first }
+      b = task_creation.call(scope.root_context) do
+        a.result.get
+        trace << :second
+      end
+      scope << a
+      scope << b
+      scope.eventLoop
+      trace.should == [:first, :second]
+    end
+  end
+end
+
+{:Fiber => lambda {|&block| Fiber.new &block},
+  :Task => lambda {|&block| Task.new(AsyncScope.new.root_context, &block)},
+}.each_pair do |klass, initialize|
+  describe "#{klass}#alive?" do
+    let(:simple_unit) { initialize.call { 2 + 2 } }
+    let(:waiting_unit) { initialize.call { Fiber.yield } }
+    it "tells you the #{klass} is alive before the #{klass} starts" do
+      simple_unit.alive?.should == true
+    end
+
+    it "tells you the #{klass} is not alive once the #{klass} has exited" do
+      simple_unit.resume
+      simple_unit.alive?.should == false
+    end
+
+    it "tells you the #{klass} is alive if the #{klass} is partially executed" do
+      waiting_unit.resume
+      # TODO: Discuss whether this should fail or not
+      waiting_unit.alive?.should == true
+    end
+  end
+end
+
+describe Task do
+
+  it "ensures that raising an error in a task is handled correctly" do
+    scope = AsyncScope.new do
+      task do
+        raise "Boo"
+      end
+    end
+    begin
+      scope.eventLoop
+    rescue Exception => e
+      e.message.should =~ /Boo.*/
+    end
+  end
+
+  it "ensures that cancelling a task will not have it remove itself twice " do
+    condition = FiberConditionVariable.new
+    scope = AsyncScope.new do
+      error_handler do |t|
+        t.begin do
+          task do
+            condition.wait
+          end
+          task do
+            condition.signal
+            # i.e.,
+            raise "simulated error"
+          end
+        end
+      end
+    end
+    expect { scope.eventLoop }.to raise_error "simulated error"
+  end
+
+
+end

data/test/aws/future_spec.rb

@@ -0,0 +1,210 @@
+##
+# 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.
+##
+
+describe Future do
+  let(:future) { Future.new }
+  let(:trace) { [] }
+  it "throws an exception when set multiple times" do
+    future.set(:foo)
+    expect { future.set(:bar) }.to raise_error AlreadySetException
+  end
+
+  it "returns the value which was set" do
+    value = :foo
+    future.set(value)
+    future.get.should == value
+  end
+
+  it "blocks a task until a value is ready" do
+    scope = AsyncScope.new do
+      task do
+        trace << :first
+        future.get
+        # TODO technically this should only be checked in a TaskContext test;
+        # a Future test would just make sure that this comes after :second
+        trace << :fourth
+      end
+
+      task do
+        trace << :second
+        future.set(:foo)
+        trace << :third
+      end
+    end
+
+    scope.eventLoop
+    trace.should == [:first, :second, :third, :fourth]
+  end
+
+  it "blocks multiple Fibers until a value is ready" do
+    scope = AsyncScope.new do
+      task do
+        trace << :first
+        future.get
+        trace << :fifth
+      end
+
+      task do
+        trace << :second
+        future.get
+        trace << :sixth
+      end
+
+      task do
+        trace << :third
+        future.set(:foo)
+        trace << :fourth
+      end
+    end
+    scope.eventLoop
+    trace.should == [:first, :second, :third, :fourth, :fifth, :sixth]
+  end
+
+  it "supports wait_for_any" do
+    scope = AsyncScope.new do
+      f1 = Future.new
+      f2 = Future.new
+      f3 = Future.new
+      trace << :before_task
+      task do
+        trace << :before_set
+        f2.set("bar")
+        trace << :after_set
+      end
+      trace << :before_wait
+
+      f = Future.wait_for_any(f1, f2, f3).first
+      trace << :after_wait
+      f.should == f2
+      f.get.should == "bar"
+    end
+    trace.length.should == 0
+    scope.eventLoop
+    trace.should == [:before_task, :before_wait, :before_set, :after_set, :after_wait]
+  end
+
+  it "supports wait_for_any with all set" do
+    scope = AsyncScope.new do
+      f1 = Future.new
+      f2 = Future.new
+      f3 = Future.new
+      trace << :before_task
+      task do
+        trace << :before_set
+        f2.set("bar")
+        f1.set("baz")
+        f3.set("foo")
+        trace << :after_set
+      end
+      trace << :before_wait
+      r1, r2, r3 = Future.wait_for_any(f1, f2, f3)
+      trace << :after_wait
+      r1.should == f2
+      r1.get.should == "bar"
+      r2.should == f1
+      r2.get.should == "baz"
+      r3.should == f3
+      r3.get.should == "foo"
+    end
+    trace.length.should == 0
+    scope.eventLoop
+    trace.should == [:before_task, :before_wait, :before_set, :after_set, :after_wait]
+  end
+
+  it "supports wait_for_all" do
+    scope = AsyncScope.new do
+      f1 = Future.new
+      f2 = Future.new
+      f3 = Future.new
+      trace << :before_task
+      task do
+        trace << :before_f2_set
+        f2.set("bar")
+        task do
+          trace << :before_f1_set
+          f1.set("baz")
+          task do
+            trace << :before_f3_set
+            f3.set("foo")
+            trace << :after_set
+          end
+        end
+      end
+      trace << :before_wait
+      r1, r2, r3 = Future.wait_for_all(f1, f2, f3)
+      trace << :after_wait
+      r1.should == f2
+      r1.get.should == "bar"
+      r2.should == f1
+      r2.get.should == "baz"
+      r3.should == f3
+      r3.get.should == "foo"
+    end
+    trace.length.should == 0
+    scope.eventLoop
+    trace.should == [:before_task, :before_wait, :before_f2_set, :before_f1_set, :before_f3_set, :after_set, :after_wait]
+  end
+
+  it "supports wait_for_all with no futures" do
+    scope = AsyncScope.new do
+      task do
+        wait_for_all
+      end
+    end
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+  it "supports wait_for_any with no futures" do
+    scope = AsyncScope.new do
+      task do
+        wait_for_any
+      end
+    end
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+  it "supports wait_for_all with a set future" do
+    scope = AsyncScope.new do
+      future = Future.new.set
+      wait_for_all(future)
+    end
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+  it "supports wait_for_any with a set future" do
+    scope = AsyncScope.new do
+      future = Future.new.set
+      wait_for_any(future)
+    end
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+  it "supports wait_for_all with one set future and one not set" do
+    future2 = Future.new
+    scope = AsyncScope.new do
+      future = Future.new.set
+      wait_for_all(future, future2)
+    end
+    scope.eventLoop
+    future2.set
+    scope.eventLoop
+    scope.is_complete?.should == true
+  end
+
+end