ntl-orchestra 0.9.0

data/test/unit/dsl_test.rb

@@ -0,0 +1,122 @@
+class DSLTest < Minitest::Test
+  def test_failing_to_supply_perform_block
+    error = assert_raises ArgumentError do
+      Orchestra::Node::InlineNode.build do
+        provides :foo
+        depends_on :bar
+      end
+    end
+
+    assert_equal "expected inline node to define a perform block", error.message
+  end
+
+  def test_two_nodes_one_name
+    error = assert_raises ArgumentError do
+      Orchestra.define do
+        node :foo do
+          depends_on :bar
+          perform do bar + bar end
+        end
+        node :foo do
+          depends_on :qux
+          perform do qux * qux end
+        end
+      end
+    end
+
+    assert_equal "There are duplicate nodes named :foo", error.message
+  end
+
+  def test_result_node
+    operation = Orchestra.define do
+      result :foo do perform do 'foo' end end
+    end
+    assert_equal :foo, operation.result
+
+    error = assert_raises ArgumentError do
+      operation = Orchestra.define do
+        result do perform do 'foo' end end
+      end
+    end
+    assert_equal "Could not infer name for node from a provision", error.message
+
+    operation = Orchestra.define do
+      result do
+        provides :foo
+        perform do 'foo' end
+      end
+    end
+    assert_equal :foo, operation.result
+  end
+
+  def test_command_operations_using_finally
+    operation = Orchestra.define do
+      node :unnecessary do
+        provides :baz
+        perform do raise "Can't get here" end
+      end
+
+      node :necessary do
+        depends_on :baz
+        provides :bar
+        perform do baz + 1 end
+      end
+
+      finally do
+        depends_on :bar
+        perform do bar * 2 end
+      end
+    end
+
+    test_observer = Module.new do
+      extend self
+      attr :result
+      def update event, *args
+        return unless event == :operation_exited
+        _, @result = args
+      end
+    end
+
+    conductor = Orchestra::Conductor.new
+    conductor.add_observer test_observer
+
+    assert_equal nil, conductor.perform(operation, :baz => 3)
+    assert_equal 8,   test_observer.result
+  end
+
+  def test_modifies
+    operation = Orchestra.define do
+      result do
+        modifies :list
+        perform do list << :foo end
+      end
+    end
+
+    ary = []
+    Orchestra.perform operation, :list => ary
+
+    assert_equal [:foo], ary
+  end
+
+  def test_must_supply_result
+    error = assert_raises ArgumentError do
+      Orchestra.define do
+        node :foo do
+          perform do 'foo' end
+        end
+      end
+    end
+
+    assert_equal "Must supply a result", error.message
+  end
+
+  def test_must_contain_at_least_one_node
+    error = assert_raises ArgumentError do
+      Orchestra.define do
+        self.result = :foo
+      end
+    end
+
+    assert_equal "Must supply at least one node", error.message
+  end
+end

data/test/unit/node_test.rb

@@ -0,0 +1,122 @@
+class NodeTest < Minitest::Test
+  def test_performing_a_node
+    node = build_simple_node
+
+    assert_equal(
+      { :bar => 4 },
+      node.perform(:foo => 2, :bar => 2),
+    )
+  end
+
+  def test_providing_a_single_hash
+    node = Orchestra::Node::InlineNode.new(
+      :dependencies => [:foo],
+      :provides => [:bar],
+      :perform_block => lambda { { :bar => (foo * 2) } },
+    )
+
+    assert_equal(
+      { :bar => 4 },
+      node.perform(:foo => 2),
+    )
+  end
+
+  def test_providing_a_single_hash_that_is_not_the_output
+    node = Orchestra::Node::InlineNode.new(
+      :dependencies => [:foo],
+      :provides => [:bar],
+      :perform_block => lambda { { :baz => (foo * 2) } },
+    )
+
+    assert_equal(
+      { :bar => { :baz => 4 } },
+      node.perform(:foo => 2),
+    )
+  end
+
+  def test_performing_a_collection_node
+    node = Orchestra::Node::InlineNode.new(
+      :dependencies => [:foo],
+      :provides => [:bar],
+      :perform_block => lambda { |e| e * 2 },
+      :collection => :foo,
+    )
+
+    assert_equal(
+      { :bar => [2, 4, 6, 8] },
+      node.perform(:foo => [1, 2, 3, 4]),
+    )
+  end
+
+  def test_defaulting
+    node = build_simple_node
+
+    assert_equal(
+      { :bar => 8 },
+      node.perform(:foo => 2),
+    )
+  end
+
+  def test_introspecting_dependencies
+    node = build_simple_node
+
+    assert_equal [:foo, :bar], node.dependencies
+  end
+
+  def test_introspecting_mandatory_dependencies
+    node = build_simple_node
+
+    assert_equal [:foo], node.required_dependencies
+  end
+
+  def test_node_fails_to_supply_provisions
+    node = Orchestra::Node::InlineNode.new(
+      :provides => [:foo, :bar, :baz],
+      :perform_block => lambda { nil },
+    )
+
+    error = assert_raises Orchestra::MissingProvisionError do node.perform end
+
+    assert_equal(
+      "failed to supply output: :foo, :bar and :baz",
+      error.message,
+    )
+  end
+
+  def test_cannot_return_nil
+    node = Orchestra::Node::InlineNode.new(
+      :provides => [:foo],
+      :perform_block => lambda do nil end
+    )
+
+    error = assert_raises Orchestra::MissingProvisionError do node.perform end
+
+    assert_equal(
+      "failed to supply output: :foo",
+      error.message,
+    )
+  end
+
+  def test_node_provides_extra_provisions
+    node = Orchestra::Node::InlineNode.new(
+      :provides => [:foo],
+      :perform_block => lambda do { :foo => :bar, :baz => :qux } end,
+    )
+
+    assert_equal(
+      { :foo => :bar },
+      node.perform,
+    )
+  end
+
+  private
+
+  def build_simple_node
+     Orchestra::Node::InlineNode.new(
+      :defaults => { :bar => lambda { 4 } },
+      :dependencies => [:foo, :bar],
+      :provides => [:bar],
+      :perform_block => lambda { foo * bar },
+    )
+  end
+end

data/test/unit/object_adapter_test.rb

@@ -0,0 +1,100 @@
+class ObjectAdapterTest < Minitest::Test
+  def setup
+    @builder = Orchestra::DSL::Operations::Builder.new
+  end
+
+  def test_method_does_not_exist_on_singleton
+    error = assert_raises NotImplementedError do
+      @builder.add_node Splitter, :provides => :words, :method => :foo
+    end
+
+    assert_equal "ObjectAdapterTest::Splitter does not implement method `foo'", error.message
+  end
+
+  def test_method_does_not_exist_on_object
+    error = assert_raises NotImplementedError do
+      @builder.add_node Upcaser, :provides => :words
+    end
+
+    assert_equal "ObjectAdapterTest::Upcaser does not implement instance method `perform'", error.message
+  end
+
+  def test_dependencies_inferred_from_method_defaults
+    node = @builder.add_node Upcaser, :iterates_over => :words, :provides => :upcased_words, :method => :call
+
+    assert_equal [:words, :transform], node.dependencies
+    assert_equal [:words], node.required_dependencies
+  end
+
+  def test_performing_an_operation_with_integrated_objects
+    operation = Orchestra.define 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
+      self.result = :joiner
+    end
+
+    result = Orchestra.perform(
+      operation,
+      :sentence  => "the quick brown fox jumps over the lazy dog",
+      :bold_text => "*",
+    )
+
+    assert_equal(
+      %(*THE* *QUICK* *BROWN* *FOX* *JUMPS* *OVER* *THE* *LAZY* *DOG*),
+      result,
+    )
+  end
+
+  def test_provent_singleton_objects_from_handling_collections
+    error = assert_raises ArgumentError do
+      Orchestra.define do
+        node Splitter, :iterates_over => :sentence
+      end
+    end
+
+    assert_equal(
+      "ObjectAdapterTest::Splitter is a singleton; cannot iterate over collection :sentence",
+      error.message
+    )
+  end
+
+  module Splitter
+    def self.perform sentence
+      sentence.split %r{[[:space:]]+}
+    end
+  end
+
+  class Upcaser
+    def initialize transform = :upcase
+      @transform = transform
+    end
+
+    def call element
+      element.public_send @transform
+    end
+  end
+
+  class Bolder
+    attr :bold_text
+
+    def initialize bold_text = "**"
+      @bold_text = bold_text
+    end
+
+    def call word
+      "#{bold_text}#{word}#{bold_text}"
+    end
+  end
+
+  class Joiner
+    def initialize bolded_words
+      @bolded_words = bolded_words
+    end
+
+    def join
+      @bolded_words.join ' '
+    end
+  end
+end

data/test/unit/operation_test.rb

@@ -0,0 +1,224 @@
+module OperationTest
+  class PerformTest < 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)),
+      )
+    end
+
+    def test_performing_operation_without_inputs
+      operation = build_simple_operation
+
+      error = assert_raises Orchestra::MissingInputError do
+        operation.perform
+      end
+
+      assert_equal %(Missing input :sentence), error.message
+    end
+
+    def test_mutating_inputs
+      operation = build_mutator
+
+      shopping_list = [%(1 clove garlic)]
+      operation.perform :shopping_list => shopping_list
+
+      assert_equal(
+        [%(1 clove garlic), %(2 bunches of carrots), %(1 stalk of celery), %(3 yellow onions)],
+        shopping_list,
+      )
+    end
+
+    def test_skipping_unnecessary_steps
+      operation = build_simple_operation
+
+      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)),
+      )
+    end
+
+    def test_passing_conductor_into_nodes
+      conductor = Orchestra::Conductor.new
+
+      node = Orchestra::Node::InlineNode.build do
+        depends_on :conductor
+        provides :conductor_id
+        perform do conductor.object_id end
+      end
+
+      assert_equal conductor.object_id, node.perform[:conductor_id]
+    end
+
+    def test_missing_input_errors
+      operation = Orchestra.define do
+        node :foo do
+          depends_on :bar
+          perform do bar + bar end
+        end
+        node :baz do
+          depends_on :qux
+          perform do qux * qux end
+        end
+        node :result do
+          depends_on :foo, :baz
+          perform do baz - foo end
+        end
+        self.result = :result
+      end
+
+      error = assert_raises Orchestra::MissingInputError do
+        Orchestra.perform operation, :bar => nil
+      end
+
+      assert_equal "Missing inputs :bar and :qux", error.message
+    end
+
+    private
+
+    def build_simple_operation
+      Orchestra.define do
+        node :split do
+          depends_on :sentence
+          provides :word_list
+          perform do sentence.split %r{[[:space:]]+} end
+        end
+
+        node :upcase do
+          depends_on :word_list
+          provides :upcased_word_list
+          perform do word_list.map &:upcase end
+        end
+
+        node :join do
+          depends_on :upcased_word_list
+          perform do upcased_word_list.join ' ' end
+        end
+
+        self.result = :join
+      end
+    end
+
+    def build_mutator
+      Orchestra.define do
+        node :carrots do
+          depends_on :shopping_list
+          provides :shopping_list
+          perform do shopping_list << "2 bunches of carrots" end
+        end
+
+        node :celery do
+          depends_on :shopping_list
+          provides :shopping_list
+          perform do shopping_list << "1 stalk of celery" end
+        end
+
+        node :onions do
+          depends_on :shopping_list
+          provides :shopping_list
+          perform do shopping_list << "3 yellow onions" end
+        end
+
+        self.result = :shopping_list
+      end
+    end
+
+  end
+
+  class IntrospectionTest < Minitest::Test
+    def test_introspecting_dependencies
+      node = Orchestra::Node::InlineNode.build do
+        depends_on :foo, :bar => :baz
+        provides :baz
+        perform do :noop end
+      end
+
+      assert_equal [:foo, :bar], node.dependencies
+    end
+
+    def test_introspecting_optional_dependencies
+      node = Orchestra::Node::InlineNode.build do
+        depends_on :foo, :bar => :baz
+        provides :qux
+        perform do :noop end
+      end
+
+      assert_equal [:bar], node.optional_dependencies
+    end
+
+    def test_introspecting_mandatory_dependencies
+      node = Orchestra::Node::InlineNode.build do
+        depends_on :foo, :bar => :baz
+        provides :baz
+        perform do :noop end
+      end
+
+      assert_equal [:foo], node.required_dependencies
+    end
+
+  end
+
+  class EmbeddingOperationsTest < Minitest::Test
+    def test_embedding_operations
+      inner = Orchestra.define do
+        node :double do
+          depends_on :number
+          provides :doubled
+          perform do number * 2 end
+        end
+
+        result :plus_one do
+          depends_on :doubled
+          perform do doubled + 1 end
+        end
+      end
+
+      outer = Orchestra.define do
+        node inner
+
+        result :squared do
+          depends_on :plus_one
+          perform do plus_one ** 2 end
+        end
+      end
+
+      telemetry = {}
+
+      conductor = Orchestra::Conductor.new
+      conductor.add_observer TelemetryRecorder.new telemetry
+
+      result = conductor.perform outer, :number => 4
+
+      assert_equal 81, result
+
+      assert_equal expected_telemetry, telemetry
+    end
+
+    private
+
+    def expected_telemetry
+      {
+        :input => { :number => 4 },
+        :movements => {
+          :double => {
+            :input  => { :number => 4 },
+            :output => { :doubled => 8 },
+          },
+          :plus_one => {
+            :input  => { :doubled => 8 },
+            :output => { :plus_one => 9 },
+          },
+          :squared => {
+            :input  => { :plus_one => 9 },
+            :output => { :squared => 81 },
+          },
+        },
+        :output => 81,
+        :performance_name => nil,
+        :service_calls => [],
+      }
+    end
+  end
+end

data/test/unit/run_list_test.rb

@@ -0,0 +1,131 @@
+class RunListTest < Minitest::Test
+  def test_all_are_required
+    builder.input_names << :foo
+
+    run_list = builder.build
+
+    assert_equal %w(foo⇒bar bar⇒baz baz⇒qux qux⇒res), run_list.node_names
+    assert_includes run_list.dependencies, :foo
+  end
+
+  def test_discards_unnecessary_nodes
+    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
+  end
+
+  def test_supplying_dependencies
+    builder.input_names << :baz
+
+    run_list = builder.build
+
+    assert_equal %w(baz⇒qux qux⇒res), run_list.node_names
+    refute_includes run_list.dependencies, :foo
+  end
+
+  def test_nodes_that_modify
+    assemble_builder modifying_nodes
+
+    run_list = builder.build
+
+    assert_equal %w(foo bar baz), run_list.node_names
+  end
+
+  def test_reorders_optional_deps_before_mandatory_deps_when_possible
+    assemble_builder order_changes_because_of_optional_deps
+
+    run_list = builder.build
+
+    assert_equal %w(baz+foo bar+baz foo+bar final), run_list.node_names
+    assert_equal [], run_list.required_dependencies
+    assert_equal [:bar, :baz, :foo], run_list.optional_dependencies
+  end
+
+  def test_wrap_tsort_cycle_errors
+    assemble_builder circular_dependency_tree
+
+    error = assert_raises Orchestra::CircularDependencyError do
+      builder.build
+    end
+
+    assert_equal(
+      "Circular dependency detected! Check your dependencies/provides",
+      error.message
+    )
+  end
+
+  private
+
+  def assemble_builder nodes = default_nodes
+    @builder ||= begin
+      builder = Orchestra::RunList::Builder.new :res
+      builder.merge! nodes
+      builder
+    end
+  end
+  alias_method :builder, :assemble_builder
+
+  def default_nodes
+    {
+      'foo⇒bar' => OpenStruct.new(:required_dependencies => [:foo], :provisions => [:bar], optional_dependencies: []),
+      'bar⇒baz' => OpenStruct.new(:required_dependencies => [:bar], :provisions => [:baz], optional_dependencies: []),
+      'baz⇒qux' => OpenStruct.new(:required_dependencies => [:baz], :provisions => [:qux], optional_dependencies: []),
+      'qux⇒res' => OpenStruct.new(:required_dependencies => [:qux], :provisions => [:res], optional_dependencies: []),
+    }
+  end
+
+  def modifying_nodes
+    {
+      'foo' => OpenStruct.new(:required_dependencies => [:shared], :provisions => [:shared], optional_dependencies: []),
+      'bar' => OpenStruct.new(:required_dependencies => [:shared], :provisions => [:shared], optional_dependencies: []),
+      'baz' => OpenStruct.new(:required_dependencies => [:shared], :provisions => [:shared, :res], optional_dependencies: []),
+    }
+  end
+
+  def circular_dependency_tree
+    {
+      'foo+bar' => OpenStruct.new(
+        :optional_dependencies => [:bar],
+        :required_dependencies => [:foo],
+        :provisions => [:aba]
+      ),
+      'bar+baz' => OpenStruct.new(
+        :optional_dependencies => [:foo],
+        :required_dependencies => [:bar],
+        :provisions => [:cab],
+      ),
+      'final'   => OpenStruct.new(
+        :optional_dependencies => [],
+        :required_dependencies => [:aba, :cab],
+        :provisions => [:res],
+      )
+    }
+  end
+
+  def order_changes_because_of_optional_deps
+    {
+      'foo+bar' => OpenStruct.new(
+        :optional_dependencies => [],
+        :required_dependencies => [:foo, :bar],
+        :provisions => [:aba]
+      ),
+      'bar+baz' => OpenStruct.new(
+        :optional_dependencies => [:bar],
+        :required_dependencies => [:baz],
+        :provisions => [:cab],
+      ),
+      'baz+foo' => OpenStruct.new(
+        :optional_dependencies => [:baz, :foo],
+        :required_dependencies => [],
+        :provisions => [:bra],
+      ),
+      'final'   => OpenStruct.new(
+        :optional_dependencies => [],
+        :required_dependencies => [:aba, :cab, :bra],
+        :provisions => [:res],
+      ),
+    }
+  end
+end