ntl-orchestra 0.9.2 → 0.9.3

data/test/unit/dsl_test.rb

@@ -1,49 +1,49 @@
 class DSLTest < Minitest::Test
-  def test_failing_to_supply_perform_block
+  def test_failing_to_supply_execute_block
     error = assert_raises ArgumentError do
-      Orchestra::Node::InlineNode.build do
+      Orchestra::Step::InlineStep.build do
         provides :foo
         depends_on :bar
       end
     end
 
-    assert_equal "expected inline node to define a perform block", error.message
+    assert_equal "expected inline step to define a execute block", error.message
   end
 
-  def test_two_nodes_one_name
+  def test_two_steps_one_name
     error = assert_raises ArgumentError do
       Orchestra::Operation.new do
-        node :foo do
+        step :foo do
           depends_on :bar
-          perform do bar + bar end
+          execute do bar + bar end
         end
-        node :foo do
+        step :foo do
           depends_on :qux
-          perform do qux * qux end
+          execute do qux * qux end
         end
       end
     end
 
-    assert_equal "There are duplicate nodes named :foo", error.message
+    assert_equal "There are duplicate steps named :foo", error.message
   end
 
-  def test_result_node
+  def test_result_step
     operation = Orchestra::Operation.new do
-      result :foo do perform do 'foo' end end
+      result :foo do execute do 'foo' end end
     end
     assert_equal :foo, operation.result
 
     error = assert_raises ArgumentError do
       operation = Orchestra::Operation.new do
-        result do perform do 'foo' end end
+        result do execute do 'foo' end end
       end
     end
-    assert_equal "Could not infer name for node from a provision", error.message
+    assert_equal "Could not infer name for step from a provision", error.message
 
     operation = Orchestra::Operation.new do
       result do
         provides :foo
-        perform do 'foo' end
+        execute do 'foo' end
       end
     end
     assert_equal :foo, operation.result
@@ -51,20 +51,20 @@ class DSLTest < Minitest::Test
 
   def test_command_operations_using_finally
     operation = Orchestra::Operation.new do
-      node :unnecessary do
+      step :unnecessary do
         provides :baz
-        perform do raise "Can't get here" end
+        execute do raise "Can't get here" end
       end
 
-      node :necessary do
+      step :necessary do
         depends_on :baz
         provides :bar
-        perform do baz + 1 end
+        execute do baz + 1 end
       end
 
       finally do
         depends_on :bar
-        perform do bar * 2 end
+        execute do bar * 2 end
       end
     end
 
@@ -80,7 +80,7 @@ class DSLTest < Minitest::Test
     conductor = Orchestra::Conductor.new
     conductor.add_observer test_observer
 
-    assert_equal nil, conductor.perform(operation, :baz => 3)
+    assert_equal nil, conductor.execute(operation, :baz => 3)
     assert_equal 8,   test_observer.result
   end
 
@@ -88,12 +88,12 @@ class DSLTest < Minitest::Test
     operation = Orchestra::Operation.new do
       result do
         modifies :list
-        perform do list << :foo end
+        execute do list << :foo end
       end
     end
 
     ary = []
-    Orchestra.perform operation, :list => ary
+    Orchestra.execute operation, :list => ary
 
     assert_equal [:foo], ary
   end
@@ -101,8 +101,8 @@ class DSLTest < Minitest::Test
   def test_must_supply_result
     error = assert_raises ArgumentError do
       Orchestra::Operation.new do
-        node :foo do
-          perform do 'foo' end
+        step :foo do
+          execute do 'foo' end
         end
       end
     end
@@ -110,13 +110,13 @@ class DSLTest < Minitest::Test
     assert_equal "Must supply a result", error.message
   end
 
-  def test_must_contain_at_least_one_node
+  def test_must_contain_at_least_one_step
     error = assert_raises ArgumentError do
       Orchestra::Operation.new do
         self.result = :foo
       end
     end
 
-    assert_equal "Must supply at least one node", error.message
+    assert_equal "Must supply at least one step", error.message
   end
 end

data/test/unit/object_adapter_test.rb

@@ -5,7 +5,7 @@ class ObjectAdapterTest < Minitest::Test
 
   def test_method_does_not_exist_on_singleton
     error = assert_raises NotImplementedError do
-      @builder.add_node Splitter, :provides => :words, :method => :foo
+      @builder.add_step Splitter, :provides => :words, :method => :foo
     end
 
     assert_equal "ObjectAdapterTest::Splitter does not implement method `foo'", error.message
@@ -13,29 +13,29 @@ class ObjectAdapterTest < Minitest::Test
 
   def test_method_does_not_exist_on_object
     error = assert_raises NotImplementedError do
-      @builder.add_node Upcaser, :provides => :words
+      @builder.add_step Upcaser, :provides => :words
     end
 
-    assert_equal "ObjectAdapterTest::Upcaser does not implement instance method `perform'", error.message
+    assert_equal "ObjectAdapterTest::Upcaser does not implement instance method `execute'", error.message
   end
 
   def test_dependencies_inferred_from_method_defaults
-    node = @builder.add_node Upcaser, :iterates_over => :words, :provides => :upcased_words, :method => :call
+    step = @builder.add_step Upcaser, :iterates_over => :words, :provides => :upcased_words, :method => :call
 
-    assert_equal [:words, :transform], node.dependencies
-    assert_equal [:words], node.required_dependencies
+    assert_equal [:words, :transform], step.dependencies
+    assert_equal [:words], step.required_dependencies
   end
 
-  def test_performing_an_operation_with_integrated_objects
+  def test_executing_an_operation_with_integrated_objects
     operation = Orchestra::Operation.new do
-      node Splitter, :provides => :words
-      node Upcaser, :iterates_over => :words, :provides => :upcased_words, :method => :call
-      node Bolder, :iterates_over => :upcased_words, :provides => :bolded_words, :method => :call
-      node Joiner, :method => :join
+      step Splitter, :provides => :words
+      step Upcaser, :iterates_over => :words, :provides => :upcased_words, :method => :call
+      step Bolder, :iterates_over => :upcased_words, :provides => :bolded_words, :method => :call
+      step Joiner, :method => :join
       self.result = :joiner
     end
 
-    result = Orchestra.perform(
+    result = Orchestra.execute(
       operation,
       :sentence  => "the quick brown fox jumps over the lazy dog",
       :bold_text => "*",
@@ -50,7 +50,7 @@ class ObjectAdapterTest < Minitest::Test
   def test_provent_singleton_objects_from_handling_collections
     error = assert_raises ArgumentError do
       Orchestra::Operation.new do
-        node Splitter, :iterates_over => :sentence
+        step Splitter, :iterates_over => :sentence
       end
     end
 
@@ -61,7 +61,7 @@ class ObjectAdapterTest < Minitest::Test
   end
 
   module Splitter
-    def self.perform sentence
+    def self.execute sentence
       sentence.split %r{[[:space:]]+}
     end
   end

data/test/unit/operation_test.rb

@@ -1,19 +1,19 @@
 module OperationTest
-  class PerformTest < Minitest::Test
+  class ExecutionTest < Minitest::Test
     def test_simple_operation
       operation = build_simple_operation
 
       assert_equal(
         %(THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG),
-        operation.perform(:sentence => %(the quick brown fox jumps over the lazy dog)),
+        operation.execute(:sentence => %(the quick brown fox jumps over the lazy dog)),
       )
     end
 
-    def test_performing_operation_without_inputs
+    def test_executing_operation_without_inputs
       operation = build_simple_operation
 
       error = assert_raises Orchestra::MissingInputError do
-        operation.perform
+        operation.execute
       end
 
       assert_equal %(Missing input :sentence), error.message
@@ -23,7 +23,7 @@ module OperationTest
       operation = build_mutator
 
       shopping_list = [%(1 clove garlic)]
-      operation.perform :shopping_list => shopping_list
+      operation.execute :shopping_list => shopping_list
 
       assert_equal(
         [%(1 clove garlic), %(2 bunches of carrots), %(1 stalk of celery), %(3 yellow onions)],
@@ -36,41 +36,41 @@ module OperationTest
 
       assert_equal(
         %(THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG),
-        operation.perform(:upcased_word_list => %w(THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG)),
+        operation.execute(:upcased_word_list => %w(THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG)),
       )
     end
 
-    def test_passing_conductor_into_nodes
+    def test_passing_conductor_into_steps
       conductor = Orchestra::Conductor.new
 
-      node = Orchestra::Node::InlineNode.build do
+      step = Orchestra::Step::InlineStep.build do
         depends_on :conductor
         provides :conductor_id
-        perform do conductor.object_id end
+        execute do conductor.object_id end
       end
 
-      assert_equal conductor.object_id, node.perform[:conductor_id]
+      assert_equal conductor.object_id, step.execute[:conductor_id]
     end
 
     def test_missing_input_errors
       operation = Orchestra::Operation.new do
-        node :foo do
+        step :foo do
           depends_on :bar
-          perform do bar + bar end
+          execute do bar + bar end
         end
-        node :baz do
+        step :baz do
           depends_on :qux
-          perform do qux * qux end
+          execute do qux * qux end
         end
-        node :result do
+        step :result do
           depends_on :foo, :baz
-          perform do baz - foo end
+          execute do baz - foo end
         end
         self.result = :result
       end
 
       error = assert_raises Orchestra::MissingInputError do
-        Orchestra.perform operation, :bar => nil
+        Orchestra.execute operation, :bar => nil
       end
 
       assert_equal "Missing inputs :bar and :qux", error.message
@@ -80,21 +80,21 @@ module OperationTest
 
     def build_simple_operation
       Orchestra::Operation.new do
-        node :split do
+        step :split do
           depends_on :sentence
           provides :word_list
-          perform do sentence.split %r{[[:space:]]+} end
+          execute do sentence.split %r{[[:space:]]+} end
         end
 
-        node :upcase do
+        step :upcase do
           depends_on :word_list
           provides :upcased_word_list
-          perform do word_list.map &:upcase end
+          execute do word_list.map &:upcase end
         end
 
-        node :join do
+        step :join do
           depends_on :upcased_word_list
-          perform do upcased_word_list.join ' ' end
+          execute do upcased_word_list.join ' ' end
         end
 
         self.result = :join
@@ -103,22 +103,22 @@ module OperationTest
 
     def build_mutator
       Orchestra::Operation.new do
-        node :carrots do
+        step :carrots do
           depends_on :shopping_list
           provides :shopping_list
-          perform do shopping_list << "2 bunches of carrots" end
+          execute do shopping_list << "2 bunches of carrots" end
         end
 
-        node :celery do
+        step :celery do
           depends_on :shopping_list
           provides :shopping_list
-          perform do shopping_list << "1 stalk of celery" end
+          execute do shopping_list << "1 stalk of celery" end
         end
 
-        node :onions do
+        step :onions do
           depends_on :shopping_list
           provides :shopping_list
-          perform do shopping_list << "3 yellow onions" end
+          execute do shopping_list << "3 yellow onions" end
         end
 
         self.result = :shopping_list
@@ -129,33 +129,33 @@ module OperationTest
 
   class IntrospectionTest < Minitest::Test
     def test_introspecting_dependencies
-      node = Orchestra::Node::InlineNode.build do
+      step = Orchestra::Step::InlineStep.build do
         depends_on :foo, :bar => :baz
         provides :baz
-        perform do :noop end
+        execute do :noop end
       end
 
-      assert_equal [:foo, :bar], node.dependencies
+      assert_equal [:foo, :bar], step.dependencies
     end
 
     def test_introspecting_optional_dependencies
-      node = Orchestra::Node::InlineNode.build do
+      step = Orchestra::Step::InlineStep.build do
         depends_on :foo, :bar => :baz
         provides :qux
-        perform do :noop end
+        execute do :noop end
       end
 
-      assert_equal [:bar], node.optional_dependencies
+      assert_equal [:bar], step.optional_dependencies
     end
 
     def test_introspecting_mandatory_dependencies
-      node = Orchestra::Node::InlineNode.build do
+      step = Orchestra::Step::InlineStep.build do
         depends_on :foo, :bar => :baz
         provides :baz
-        perform do :noop end
+        execute do :noop end
       end
 
-      assert_equal [:foo], node.required_dependencies
+      assert_equal [:foo], step.required_dependencies
     end
 
   end
@@ -163,24 +163,24 @@ module OperationTest
   class EmbeddingOperationsTest < Minitest::Test
     def test_embedding_operations
       inner = Orchestra::Operation.new do
-        node :double do
+        step :double do
           depends_on :number
           provides :doubled
-          perform do number * 2 end
+          execute do number * 2 end
         end
 
         result :plus_one do
           depends_on :doubled
-          perform do doubled + 1 end
+          execute do doubled + 1 end
         end
       end
 
       outer = Orchestra::Operation.new do
-        node inner
+        step inner
 
         result :squared do
           depends_on :plus_one
-          perform do plus_one ** 2 end
+          execute do plus_one ** 2 end
         end
       end
 
@@ -189,7 +189,7 @@ module OperationTest
       conductor = Orchestra::Conductor.new
       conductor.add_observer TelemetryRecorder.new telemetry
 
-      result = conductor.perform outer, :number => 4
+      result = conductor.execute outer, :number => 4
 
       assert_equal 81, result
 
@@ -216,7 +216,7 @@ module OperationTest
           },
         },
         :output => 81,
-        :performance_name => nil,
+        :operation_name => nil,
         :service_calls => [],
       }
     end

data/test/unit/run_list_test.rb

@@ -4,16 +4,16 @@ class RunListTest < Minitest::Test
 
     run_list = builder.build
 
-    assert_equal %w(foo⇒bar bar⇒baz baz⇒qux qux⇒res), run_list.node_names
+    assert_equal %w(foo⇒bar bar⇒baz baz⇒qux qux⇒res), run_list.step_names
     assert_includes run_list.dependencies, :foo
   end
 
-  def test_discards_unnecessary_nodes
+  def test_discards_unnecessary_steps
     builder['aba⇒cab'] = OpenStruct.new :required_dependencies => [:aba], :optional_dependencies => [], :provisions => [:cab]
 
     run_list = builder.build
 
-    assert_equal %w(foo⇒bar bar⇒baz baz⇒qux qux⇒res), run_list.node_names
+    assert_equal %w(foo⇒bar bar⇒baz baz⇒qux qux⇒res), run_list.step_names
   end
 
   def test_supplying_dependencies
@@ -21,16 +21,16 @@ class RunListTest < Minitest::Test
 
     run_list = builder.build
 
-    assert_equal %w(baz⇒qux qux⇒res), run_list.node_names
+    assert_equal %w(baz⇒qux qux⇒res), run_list.step_names
     refute_includes run_list.dependencies, :foo
   end
 
-  def test_nodes_that_modify
-    assemble_builder modifying_nodes
+  def test_steps_that_modify
+    assemble_builder modifying_steps
 
     run_list = builder.build
 
-    assert_equal %w(foo bar baz), run_list.node_names
+    assert_equal %w(foo bar baz), run_list.step_names
   end
 
   def test_reorders_optional_deps_before_mandatory_deps_when_possible
@@ -38,7 +38,7 @@ class RunListTest < Minitest::Test
 
     run_list = builder.build
 
-    assert_equal %w(baz+foo bar+baz foo+bar final), run_list.node_names
+    assert_equal %w(baz+foo bar+baz foo+bar final), run_list.step_names
     assert_equal [], run_list.required_dependencies
     assert_equal [:bar, :baz, :foo], run_list.optional_dependencies
   end
@@ -58,16 +58,16 @@ class RunListTest < Minitest::Test
 
   private
 
-  def assemble_builder nodes = default_nodes
+  def assemble_builder steps = default_steps
     @builder ||= begin
       builder = Orchestra::RunList::Builder.new :res
-      builder.merge! nodes
+      builder.merge! steps
       builder
     end
   end
   alias_method :builder, :assemble_builder
 
-  def default_nodes
+  def default_steps
     {
       'foo⇒bar' => OpenStruct.new(:required_dependencies => [:foo], :provisions => [:bar], optional_dependencies: []),
       'bar⇒baz' => OpenStruct.new(:required_dependencies => [:bar], :provisions => [:baz], optional_dependencies: []),
@@ -76,7 +76,7 @@ class RunListTest < Minitest::Test
     }
   end
 
-  def modifying_nodes
+  def modifying_steps
     {
       'foo' => OpenStruct.new(:required_dependencies => [:shared], :provisions => [:shared], optional_dependencies: []),
       'bar' => OpenStruct.new(:required_dependencies => [:shared], :provisions => [:shared], optional_dependencies: []),

data/test/unit/step_test.rb

@@ -0,0 +1,122 @@
+class StepTest < Minitest::Test
+  def test_invoking_a_step
+    step = build_simple_step
+
+    assert_equal(
+      { :bar => 4 },
+      step.execute(:foo => 2, :bar => 2),
+    )
+  end
+
+  def test_providing_a_single_hash
+    step = Orchestra::Step::InlineStep.new(
+      :dependencies => [:foo],
+      :provides => [:bar],
+      :execute_block => lambda { { :bar => (foo * 2) } },
+    )
+
+    assert_equal(
+      { :bar => 4 },
+      step.execute(:foo => 2),
+    )
+  end
+
+  def test_providing_a_single_hash_that_is_not_the_output
+    step = Orchestra::Step::InlineStep.new(
+      :dependencies => [:foo],
+      :provides => [:bar],
+      :execute_block => lambda { { :baz => (foo * 2) } },
+    )
+
+    assert_equal(
+      { :bar => { :baz => 4 } },
+      step.execute(:foo => 2),
+    )
+  end
+
+  def test_invoking_a_collection_step
+    step = Orchestra::Step::InlineStep.new(
+      :dependencies => [:foo],
+      :provides => [:bar],
+      :execute_block => lambda { |e| e * 2 },
+      :collection => :foo,
+    )
+
+    assert_equal(
+      { :bar => [2, 4, 6, 8] },
+      step.execute(:foo => [1, 2, 3, 4]),
+    )
+  end
+
+  def test_defaulting
+    step = build_simple_step
+
+    assert_equal(
+      { :bar => 8 },
+      step.execute(:foo => 2),
+    )
+  end
+
+  def test_introspecting_dependencies
+    step = build_simple_step
+
+    assert_equal [:foo, :bar], step.dependencies
+  end
+
+  def test_introspecting_mandatory_dependencies
+    step = build_simple_step
+
+    assert_equal [:foo], step.required_dependencies
+  end
+
+  def test_step_fails_to_supply_provisions
+    step = Orchestra::Step::InlineStep.new(
+      :provides => [:foo, :bar, :baz],
+      :execute_block => lambda { nil },
+    )
+
+    error = assert_raises Orchestra::MissingProvisionError do step.execute end
+
+    assert_equal(
+      "failed to supply output: :foo, :bar and :baz",
+      error.message,
+    )
+  end
+
+  def test_cannot_return_nil
+    step = Orchestra::Step::InlineStep.new(
+      :provides => [:foo],
+      :execute_block => lambda do nil end
+    )
+
+    error = assert_raises Orchestra::MissingProvisionError do step.execute end
+
+    assert_equal(
+      "failed to supply output: :foo",
+      error.message,
+    )
+  end
+
+  def test_step_provides_extra_provisions
+    step = Orchestra::Step::InlineStep.new(
+      :provides => [:foo],
+      :execute_block => lambda do { :foo => :bar, :baz => :qux } end,
+    )
+
+    assert_equal(
+      { :foo => :bar },
+      step.execute,
+    )
+  end
+
+  private
+
+  def build_simple_step
+     Orchestra::Step::InlineStep.new(
+      :defaults => { :bar => lambda { 4 } },
+      :dependencies => [:foo, :bar],
+      :provides => [:bar],
+      :execute_block => lambda { foo * bar },
+    )
+  end
+end

data/test/unit/thread_pool_test.rb

@@ -49,7 +49,7 @@ class ThreadPoolTest < Minitest::Test
 
   def test_performing_work
     @iterations.times do
-      result = @thread_pool.perform do :deadbeef end
+      result = @thread_pool.execute do :deadbeef end
 
       assert_equal :deadbeef, result
     end
@@ -77,7 +77,7 @@ class ThreadPoolTest < Minitest::Test
     10.times do
       assert_raises NoMethodError do
         input.each do |num|
-          @thread_pool.perform do num * 2 end
+          @thread_pool.execute do num * 2 end
         end
       end
     end