trailblazer-operation 0.0.13 → 0.1.1

data/test/task_wrap_test.rb

@@ -0,0 +1,91 @@
+require "test_helper"
+
+require "trailblazer/operation/inject" # an optional feature.com.
+
+class TaskWrapTest < Minitest::Spec
+  MyMacro = ->( (options, *args), *) do
+    options["MyMacro.contract"] = options[:contract]
+    [ Trailblazer::Activity::Right, [options, *args] ]
+  end
+
+  class Create < Trailblazer::Operation
+    step :model!
+    # step [ MyMacro, { name: "MyMacro" }, { dependencies: { "contract" => :external_maybe } }]
+    step(
+      task: MyMacro,
+      id: "MyMacro",
+
+      runner_options: {
+        merge: Trailblazer::Activity::Magnetic::Builder::Path.plan do
+          task Trailblazer::Operation::Wrap::Inject::ReverseMergeDefaults.new( contract: "MyDefaultContract" ),
+            id:     "inject.my_default",
+            before: "task_wrap.call_task"
+        end
+      }
+
+    )
+
+    def model!(options, **)
+      options["options.contract"] = options[:contract]
+      true
+    end
+  end
+
+  # it { Create.__call__("adsf", options={}, {}).inspect("MyMacro.contract", "options.contract").must_equal %{} }
+
+  def inspect_hash(hash, *keys)
+    Hash[ keys.collect { |key| [key, hash[key]] } ].inspect
+  end
+
+  #-
+  # default gets set by Injection.
+  it do
+    direction, (options, _) = Create.__call__( [{}, {}] )
+
+
+    inspect_hash(options, "options.contract", :contract, "MyMacro.contract").
+      must_equal %{{"options.contract"=>nil, :contract=>"MyDefaultContract", "MyMacro.contract"=>"MyDefaultContract"}}
+  end
+
+  # injected from outside, Injection skips.
+  it do
+    direction, (options, _) = Create.__call__( [ { :contract=>"MyExternalContract" }, {} ] )
+
+    inspect_hash(options, "options.contract", :contract, "MyMacro.contract").
+      must_equal %{{"options.contract"=>"MyExternalContract", :contract=>"MyExternalContract", "MyMacro.contract"=>"MyExternalContract"}}
+  end
+
+  #- Nested task_wraps should not override the outer.
+  AnotherMacro = ->( (options, *args), *) do
+    options["AnotherMacro.another_contract"] = options[:another_contract]
+    [ Trailblazer::Activity::Right, [options, *args] ]
+  end
+
+  class Update < Trailblazer::Operation
+    step(
+      task: ->( (options, *args), * ) {
+          _d, *o = Create.__call__( [ options, *args ] )
+
+          [ Trailblazer::Activity::Right, *o ]
+        },
+      id: "Create"
+    )
+    step(
+      task:           AnotherMacro,
+      id:             "AnotherMacro",
+      runner_options: {
+        merge: Trailblazer::Activity::Magnetic::Builder::Path.plan do
+          task Trailblazer::Operation::Wrap::Inject::ReverseMergeDefaults.new( another_contract: "AnotherDefaultContract" ), id: "inject.my_default",
+          before: "task_wrap.call_task"
+        end
+      }
+    )
+  end
+
+  it do
+    direction, (options, _) = Update.__call__( [ {}, {} ] )
+
+    inspect_hash(options, "options.contract", :contract, "MyMacro.contract", "AnotherMacro.another_contract").
+      must_equal %{{"options.contract"=>nil, :contract=>"MyDefaultContract", "MyMacro.contract"=>"MyDefaultContract", "AnotherMacro.another_contract"=>"AnotherDefaultContract"}}
+  end
+end

data/test/test_helper.rb

@@ -1,2 +1,39 @@
+require "pp"
+
 require "minitest/autorun"
 require "trailblazer/operation"
+
+Minitest::Spec::Activity = Trailblazer::Activity
+
+module Test
+  # Create a step method in `klass` with the following body.
+  #
+  #   def a(options, a_return:, data:, **)
+  #     data << :a
+  #
+  #     a_return
+  #   end
+  def self.step(klass, *names)
+    names.each do |name|
+      method_def =
+        %{def #{name}(options, #{name}_return:, data:, **)
+          data << :#{name}
+
+          #{name}_return
+        end}
+
+      klass.class_eval(method_def)
+    end
+  end
+
+  # builder for PlusPoles
+  def self.plus_poles_for(mapping)
+    ary = mapping.collect { |evt, semantic| [Trailblazer:: Activity::Output(evt, semantic), semantic ] }
+
+    Trailblazer::Activity::Magnetic::DSL::PlusPoles.new.merge(::Hash[ary])
+  end
+end
+
+Minitest::Spec.class_eval do
+
+end

data/test/trace_test.rb

@@ -0,0 +1,62 @@
+require "test_helper"
+
+class TraceTest < Minitest::Spec
+  class B < Trailblazer::Operation
+    step ->(options, **) { options[:b] = true }, id: "B.task.b"
+    step ->(options, **) { options[:e] = true }, id: "B.task.e"
+
+    def self.call( (options, flow_options), **circuit_options )
+      __call__( [Trailblazer::Context(options), flow_options], circuit_options )
+    end
+  end
+
+  class Create < Trailblazer::Operation
+    step ->(options, a_return:, **) { options[:a] = a_return }, id: "Create.task.a"
+    step( {task: B, id: "MyNested"}, B.outputs[:success] => :success )
+    step ->(options, **) { options[:c] = true }, id: "Create.task.c"
+    step ->(options, params:, **) { params.any? }, id: "Create.task.params"
+
+    def self.call( (options, flow_options), **circuit_options )
+      __call__( [Trailblazer::Context(options), flow_options], circuit_options ) # FIXME.
+    end
+  end
+  # raise Create["__task_wraps__"].inspect
+
+  it "allows using low-level Activity::Trace" do
+    operation = ->(*args) { puts "@@@@@ #{args.last.inspect}"; Create.__call__(*args) }
+
+    stack, _ = Trailblazer::Activity::Trace.(
+      Create,
+      [
+        { a_return: true, "params" => {} },
+      ]
+    )
+
+    puts output = Trailblazer::Activity::Trace::Present.tree(stack)
+
+    output.gsub(/0x\w+/, "").gsub(/@.+_test/, "").must_equal %{|-- #<Trailblazer::Activity::Start:>
+|-- Create.task.a
+|-- MyNested
+|   |-- #<Trailblazer::Activity::Start:>
+|   |-- B.task.b
+|   |-- B.task.e
+|   `-- #<Trailblazer::Operation::Railway::End::Success:>
+|-- Create.task.c
+|-- Create.task.params
+`-- #<Trailblazer::Operation::Railway::End::Failure:>}
+  end
+
+  it "Operation::trace" do
+    result = Create.trace({ "params" => { x: 1 }, a_return: true })
+    result.wtf.gsub(/0x\w+/, "").gsub(/@.+_test/, "").must_equal %{|-- #<Trailblazer::Activity::Start:>
+|-- Create.task.a
+|-- MyNested
+|   |-- #<Trailblazer::Activity::Start:>
+|   |-- B.task.b
+|   |-- B.task.e
+|   `-- #<Trailblazer::Operation::Railway::End::Success:>
+|-- Create.task.c
+|-- Create.task.params
+`-- #<Trailblazer::Operation::Railway::End::Success:>}
+  end
+end

data/test/variable_mapping_test.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+
+# Test input- and output filter for specific tasks.
+# These are task wrap steps added before and after the task.
+class VariableMappingTest < Minitest::Spec
+  # first task
+  Model = ->((options, flow), **o) do
+    options["a"]        = options["a"] * 2 # rename to model.a
+    options["model.nonsense"] = true       # filter me out
+
+    [Activity::Right, [options, flow]]
+  end
+
+  # second task
+  Uuid = ->((options, flow), **o) do
+    options["a"]             = options["a"] + options["model.a"] # rename to uuid.a
+    options["uuid.nonsense"] = false                             # filter me out
+
+    [Activity::Right, [options, flow]]
+  end
+
+  let (:activity) do
+    Activity.build do
+      task Model
+      task Uuid
+    end
+  end
+
+  describe "input/output" do
+
+    it do
+      model_input  = ->(options) { { "a"       => options["a"]+1 } }
+      model_output = ->(options) { { "model.a" => options["a"] } }
+      uuid_input   = ->(options) { { "a"       => options["a"]*3, "model.a" => options["model.a"] } }
+      uuid_output  = ->(options) { { "uuid.a"  => options["a"] } }
+
+      runtime = Hash.new([])
+
+      # add filters around Model.
+      runtime[ Model ] = Activity::Magnetic::Builder::Path.plan do
+        task Activity::Wrap::Input.new( model_input ),   id: "task_wrap.input", before: "task_wrap.call_task"
+        task Activity::Wrap::Output.new( model_output ), id: "task_wrap.output", before: "End.success", group: :end
+      end
+
+      # add filters around Uuid.
+      runtime[ Uuid ] = Activity::Magnetic::Builder::Path.plan do
+        task Activity::Wrap::Input.new( uuid_input ),   id: "task_wrap.input", before: "task_wrap.call_task"
+        task Activity::Wrap::Output.new( uuid_output ), id: "task_wrap.output", before: "End.success", group: :end
+      end
+
+      signal, (options, flow_options) = activity.(
+      [
+        options = { "a" => 1 },
+        {},
+      ],
+
+      wrap_runtime: runtime, # dynamic additions from the outside (e.g. tracing), also per task.
+      runner: Activity::Wrap::Runner,
+      wrap_static: Hash.new( Activity::Wrap.initial_activity ), # per activity?
+    )
+
+    signal.must_equal activity.outputs[:success].signal
+    options.must_equal({"a"=>1, "model.a"=>4, "uuid.a" => 7 })
+    end
+  end
+end

data/test/wire_test.rb

@@ -0,0 +1,113 @@
+# require "test_helper"
+# # require "trailblazer/developer"
+
+# class WireTest < Minitest::Spec
+#   Circuit = Trailblazer::Circuit
+#   ExceptionFromD = Class.new               # custom signal
+
+#   D = ->((options, *args), *) do
+#     options["D"] = [ options["a"], options["b"], options["c"] ]
+
+#     signal = options["D_return"]
+#     [ signal, [ options, *args ] ]
+#   end
+
+#   #---
+#   #- step providing all :outputs manually.
+#   class Create < Trailblazer::Operation
+#     step ->(options, **) { options["a"] = 1 }
+#     step ->(options, **) { options["b"] = 2 }, name: "b"
+
+#     step( { task: D,
+#       outputs: { Circuit::Right => :success, Circuit::Left => :failure, ExceptionFromD => :exception }, # any outputs and their polarization, generic.
+#       id: :d,
+#       },
+#       :exception => MyEnd = End("End.ExceptionFromD_happened")
+#     )
+
+#     fail ->(options, **) { options["f"] = 4 }, id: "f"
+#     step ->(options, **) { options["c"] = 3 }, id: "c"
+#   end
+
+#   # myend ==> d
+#   it { Trailblazer::Operation::Inspect.(Create).gsub(/0x.+?wire_test.rb/, "").must_equal %{[>#<Proc::18 (lambda)>,>b,>d,<<f,>c]} }
+
+#   # normal flow as D sits on the Right track.
+#   it do
+#     result = Create.({}, "D_return" => Circuit::Right)
+
+#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:true [1, 2, 3, [1, 2, nil], nil] >}
+#     result.event.must_equal Create.outputs.keys[1]
+#   end
+
+#   # ends on MyEnd, without hitting fail.
+#   it do
+#     result = Create.({}, "D_return" => ExceptionFromD)
+
+#     result.event.must_equal Create::MyEnd
+#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], nil] >}
+#   end
+
+#   # normal flow to left track.
+#   it do
+#     result = Create.({}, "D_return" => Circuit::Left)
+
+#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], 4] >}
+#     result.event.must_equal Create.outputs.keys[0]
+#   end
+
+#   #---
+#   #- step with Merge
+#   class CreateWithDefaults < Trailblazer::Operation
+#     step ->(options, **) { options["a"] = 1 }
+#     step ->(options, **) { options["b"] = 2 }, name: "b"
+
+#     step( { task: D,
+#       outputs: Merge( ExceptionFromD => { role: :exception } ), # any outputs and their polarization, generic.
+#       id: :d,
+#       },
+#       :exception => MyEnd = End("End.ExceptionFromD_happened")
+#     )
+
+#     fail ->(options, **) { options["f"] = 4 }, id: "f"
+#     step ->(options, **) { options["c"] = 3 }, id: "c"
+#   end
+
+#   # normal flow as D sits on the Right track.
+#   it do
+#     result = CreateWithDefaults.({}, "D_return" => Circuit::Right)
+
+#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:true [1, 2, 3, [1, 2, nil], nil] >}
+#     result.event.must_equal CreateWithDefaults.outputs.keys[1]
+#   end
+
+#   # ends on MyEnd, without hitting fail.
+#   it do
+#     result = CreateWithDefaults.({}, "D_return" => ExceptionFromD)
+
+#     result.event.must_equal CreateWithDefaults::MyEnd
+#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], nil] >}
+#   end
+
+#   # normal flow to left track.
+#   it do
+#     result = CreateWithDefaults.({}, "D_return" => Circuit::Left)
+
+#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], 4] >}
+#     result.event.must_equal CreateWithDefaults.outputs.keys[0]
+#   end
+
+# end
+
+# class WireExceptionTest < Minitest::Spec
+#   # role in :outputs can't be connected because not in :connect_to.
+#   it do
+#     exception = assert_raises do
+#       class Create < Trailblazer::Operation
+#         step :a, outputs: { "some" => { role: :success } }, connect_to: { :not_existent => "End.success" }
+#       end
+#     end
+
+#     exception.message.must_equal %{Couldn't map output role :success for {:not_existent=>"End.success"}}
+#   end
+# end

data/test/wiring/defaults_test.rb

@@ -0,0 +1,197 @@
+require "test_helper"
+
+# class WireDefaultsTest < Minitest::Spec
+  # class C < Trailblazer::Operation
+  #   # here, D has a step interface!
+  #   D = ->(options, a:raise, b:raise, **) {
+  #     options["D"] = [ a, b, options["c"] ]
+
+  #     options["D_return"]
+  #   }
+
+  #   ExceptionFromD = Class.new(Circuit::Signal) # for steps, return value has to be subclass of Signal to be passed through as a signal and not a boolean.
+  #   MyEnd = Class.new(Circuit::End)
+
+  #   step ->(options, **) { options["a"] = 1 }, id: "a"
+  #   step ->(options, **) { options["b"] = 2 }, id: "b"
+
+  #   attach  MyEnd.new(:myend), id: "End.myend"
+
+  #   # step provides defaults:
+  #   step D,
+  #     outputs:       Merge( ExceptionFromD => { role: :exception } ),
+  #     connect_to:    Merge( exception: "End.myend" ),
+  #     id:            "d"
+
+  #   fail ->(options, **) { options["f"] = 4 }, id: "f"
+  #   step ->(options, **) { options["c"] = 3 }, id: "c"
+  # end
+
+#   # normal flow as D sits on the Right track.
+#   it { C.( "D_return" => Circuit::Right).inspect("a", "b", "c", "D", "f").must_equal %{<Result:true [1, 2, 3, [1, 2, nil], nil] >} }
+#   # ends on MyEnd, without hitting fail.
+#   it { C.( "D_return" => C::ExceptionFromD).inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], nil] >} } # todo: HOW TO CHECK End instance?
+#   it { C.( "D_return" => Circuit::Left).inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], 4] >} } # todo: HOW TO CHECK End instance?
+#   it do
+#       step1 = C["__sequence__"][0].instructions[0].last[:node][0]
+#       step2 = C["__sequence__"][1].instructions[0].last[:node][0]
+#       step3 = C["__sequence__"][3].instructions[0].last[:node][0] # D
+#       step4 = C["__sequence__"][4].instructions[0].last[:node][0]
+#       step5 = C["__sequence__"][5].instructions[0].last[:node][0]
+
+#       require "trailblazer/activity/schema"
+
+#       Output = Trailblazer::Activity::Schema::Output
+
+#       steps = [
+#         [ [:success], step1, [Output.new(Circuit::Right, :success), Output.new(Circuit::Left, :failure)] ],
+#         [ [:success], step2, [Output.new(Circuit::Right, :success), Output.new(Circuit::Left, :failure)] ],
+
+#         [ [:success], step3, [Output.new(Circuit::Right, :success), Output.new(Circuit::Left, :failure), Output.new(C::ExceptionFromD, :exception)] ],
+#         [ [:exception], C::MyEnd.new(:myend), [] ],
+
+#         [ [:failure], step4, [Output.new(Circuit::Right, :failure), Output.new(Circuit::Left, :failure)] ],
+#         [ [:success], step5, [Output.new(Circuit::Right, :success), Output.new(Circuit::Left, :failure)] ],
+#       ]
+
+#       ends = [
+#         [ [:success], Trailblazer::Operation::Railway::End::Success.new(:success), [] ],
+#         [ [:failure], Trailblazer::Operation::Railway::End::Failure.new(:failure), [] ],
+#       ]
+
+
+#       graph = Trailblazer::Activity::Schema.bla(steps + ends)
+#       circuit = Trailblazer::Activity.new(graph)
+#       # pp schema
+
+#       C["__activity__"] = circuit # this is so wrong
+#       C.( "D_return" => Circuit::Right).inspect("a", "b", "c", "D", "f").must_equal %{<Result:true [1, 2, 3, [1, 2, nil], nil] >}
+
+#     end
+# end
+
+# # step :a
+# # fail :b, connect_to: { Circuit::Right => "End.success" }
+# # fail :c, connect_to: { Circuit::Right => "End.success" }
+
+# Connect failure steps to right track, allowing to append steps after.
+# @see https://github.com/trailblazer/trailblazer/issues/190#issuecomment-326992255
+class WireDefaultsEarlyExitSuccessTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step :a
+    fail :b, Output(:success) => :success #{}"End.success"
+    fail :c, Output(:success) => :success
+
+    Test.step(self, :a, :b, :c)
+  end
+
+  # a => true
+  it { Create.( a_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a]] >} }
+  # b => true
+  it { Create.( a_return: false, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b]] >} }
+  # c => true
+  it { Create.( a_return: false, b_return: false, c_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :c]] >} }
+  # a => b => c => false
+  it { Create.( a_return: false, b_return: false, c_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b, :c]] >} }
+
+#   # require "trailblazer/developer"
+#   # it { Trailblazer::Developer::Client.push( operation: Create, name: "ushi" ) }
+
+
+#   #---
+#   # with => :success, steps can still be added before End.success and they will be executed.
+  class Update < Create
+    pass :d
+
+    def d(options, data:, **)
+      data << :d
+    end
+  end
+
+  # a => true
+  it { Update.( a_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :d]] >} }
+  # b => true
+  it { Update.( a_return: false, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :d]] >} }
+  # c => true
+  it { Update.( a_return: false, b_return: false, c_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :c, :d]] >} }
+  # a => b => c => false
+  it { Update.( a_return: false, b_return: false, c_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b, :c]] >} }
+
+  #---
+  # failure steps reference End.success and not just the polarization. This won't call #d in failure=>success case.
+  class Delete < Trailblazer::Operation
+    step :a
+    fail :b, Output(:success) => "End.success"
+    fail :c, Output(:success) => "End.success"
+    pass :d
+
+    Test.step(self, :a, :b, :c)
+
+    def d(options, data:, **)
+      data << :d
+    end
+  end
+
+  # a => true
+  it { Delete.( a_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :d]] >} }
+  # b => true
+  it { Delete.( a_return: false, b_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b]] >} }
+  # c => true
+  it { Delete.( a_return: false, b_return: false, c_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :c]] >} }
+  # a => b => c => false
+  it { Delete.( a_return: false, b_return: false, c_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b, :c]] >} }
+
+  #---
+  #       |----|
+  # a --> b c--d --> E.s
+  # |_____|_|_______ E.f
+  class Connect < Trailblazer::Operation
+    step :a
+    step :b, Output(:success) => "d"
+    step :c, magnetic_to: [] # otherwise :success will be an open input!
+    pass :d, id: "d"
+
+    Test.step(self, :a, :b, :c)
+
+    def d(options, data:, **)
+      data << :d
+    end
+  end
+
+  it { puts Trailblazer::Activity::Magnetic::Introspect.seq( Connect ) }
+
+  # a => true
+  it { Connect.( a_return: true, b_return: true,data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :d]] >} }
+  # a => false
+  it { Connect.( a_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a]] >} }
+  # b => false
+  it { Connect.( a_return: true, b_return: false, data: []).inspect(:data).must_equal %{<Result:false [[:a, :b]] >} }
+
+  #---
+  # |---------|
+  # |         V
+  # a    c----d --
+  # |\   ^\    \
+  # | \ /  V
+  # |__f____g----E.f
+  class Post < Trailblazer::Operation
+    step :a, Output(:success) => "d", id: "a"
+    fail :f, Output(:success) => "c"
+    step :c, magnetic_to: [], id: "c" # otherwise :success will be an open input!
+    fail :g
+    step :d, id: "d"
+
+    Test.step(self, :a, :f, :c, :g, :d)
+  end
+
+  pp Post["__sequence__"]
+
+  # a => true
+  it { Post.( a_return: true, d_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :d]] >} }
+  # a => false
+  it { Post.( a_return: false, f_return: false, g_return: nil, data: []).inspect(:data).must_equal %{<Result:false [[:a, :f, :g]] >} }
+  # a => false, f => true
+  it { Post.( a_return: false, f_return: true, c_return: true, d_return: true, data: []).inspect(:data).must_equal %{<Result:true [[:a, :f, :c, :d]] >} }
+  # a => false, f => true, c => false
+  it { Post.( a_return: false, f_return: true, c_return: false, g_return: true, data: []).inspect(:data).must_equal %{<Result:false [[:a, :f, :c, :g]] >} }
+end