trailblazer-operation 0.0.13 → 0.4.1

data/test/dry_container_test.rb

@@ -11,6 +11,10 @@ class DryContainerTest < Minitest::Spec
   class Create < Trailblazer::Operation
   end
 
+  it "allows 2.2 call style" do
+    Create.({}, my_container)["user_repository"].must_equal Object
+  end
+
   it { Create.({}, {}, my_container)["user_repository"].must_equal Object }
   it { Create.({}, {}, my_container)["contract.create"].must_equal Array }
   # also allows our own options PLUS containers.

data/test/fast_track_test.rb

@@ -0,0 +1,197 @@
+require "test_helper"
+
+class FastTrackTest < Minitest::Spec
+  # #failure fails fast.
+  # class Create < Trailblazer::Operation
+  #   step ->(options, *) { options["x"] = options["dont_fail"] }
+  #   failure ->(options, *) { options["a"] = true; options["fail_fast"] }, fail_fast: true
+  #   failure ->(options, *) { options["b"] = true }
+  #   step ->(options, *) { options["y"] = true }
+  # end
+
+  # puts Create["pipetree"].inspect
+
+  # require "trailblazer/diagram/bpmn"
+  # puts Trailblazer::Diagram::BPMN.to_xml(Create["pipetree"])
+
+  # it { Create.("fail_fast" => true, "dont_fail" => true ).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, nil, nil, true] >} }
+  # it { Create.("fail_fast" => true                  ).inspect("x", "a", "b", "y").must_equal %{<Result:false [nil, true, nil, nil] >} }
+  # it { Create.("fail_fast" => false                 ).inspect("x", "a", "b", "y").must_equal %{<Result:false [nil, true, nil, nil] >} }
+
+  # #success passes fast.
+  class Retrieve < Trailblazer::Operation
+    pass ->(options, **) { options["x"] = options["dont_fail"] }, pass_fast: true
+    fail ->(options, **) { options["b"] = true }
+    step ->(options, **) { options["y"] = true }
+  end
+  it { Retrieve.("dont_fail" => true  ).inspect("x", "b", "y").must_equal %{<Result:true [true, nil, nil] >} }
+  it { Retrieve.("dont_fail" => false ).inspect("x", "b", "y").must_equal %{<Result:true [false, nil, nil] >} }
+
+  # #step fails fast if option set and returns false.
+  class Update < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true }
+    step ->(options, *) { options["a"] = options["dont_fail"] }, fail_fast: true # only on false.
+    failure ->(options, *) { options["b"] = true }
+    step ->(options, *) { options["y"] = true }
+  end
+
+  it { Update.("dont_fail" => true).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, true, nil, true] >} }
+  it { Update.({}                     ).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, nil, nil] >} }
+
+  # #step passes fast if option set and returns true.
+  class Delete < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true }
+    step ->(options, *) { options["a"] = options["dont_fail"] }, pass_fast: true # only on true.
+    fail ->(options, *) { options["b"] = true }
+    step ->(options, *) { options["y"] = true }
+  end
+
+  it { Delete.("dont_fail" => true).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, true, nil, nil] >} }
+  it { Delete.({}                     ).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, true, nil] >} }
+end
+
+class FailBangTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.fail! }
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, true] >} }
+end
+
+class PassBangTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.pass! }
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, true, nil] >} }
+end
+
+class FailFastBangTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.fail_fast! }
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  # without proper configuration, emitting a FastTrack signal is illegal.
+  it { assert_raises(Trailblazer::Circuit::IllegalSignalError) { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, nil] >} } }
+
+  class Update < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.fail_fast! }, fast_track: true
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Update.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, nil] >} }
+end
+
+class PassFastBangTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.pass_fast! }, fast_track: true
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, nil, nil] >} }
+end
+
+#-
+class NestedFastTrackTest < Minitest::Spec
+  #- The ::step DSL method automatically connects the nested's End.fail_fast/End.pass_fast to Update's End.fail_fast/End.pass_fast.
+  #
+  # Edit has fast-tracked steps, so it has outputs :success/:failure/:pass_fast/:fail_fast.
+  class Edit < Trailblazer::Operation
+    step :a, fast_track: true # task is connected to End.pass_fast and End.fail_fast.
+
+    def a(options, edit_return:, **)
+      options["a"] = 1
+      edit_return # End.success, End.pass_fast, etc.
+    end
+  end
+
+  module Steps
+    def b(options, a:, **)
+      options["b"] = a+1
+    end
+
+    def f(options, **)
+      options["f"] = 3
+    end
+  end
+
+  describe "Nested, fast_track: true and all its outputs given" do
+    let(:update) do
+      Class.new(Trailblazer::Operation) do
+        step task: Trailblazer::Operation::Callable( Edit, call: :call_with_circuit_interface ), id: "Callable/",
+          outputs: Edit.outputs ,
+          fast_track: true
+        step :b
+        fail :f
+
+        include Steps
+      end
+    end
+
+    # Edit returns End.success
+    it { update.(edit_return: true).inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >} }
+    # Edit returns End.failure
+    it { update.(edit_return: false).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, 3] >} }
+    # Edit returns End.pass_fast
+    it { update.(edit_return: Trailblazer::Operation::Railway.pass_fast!).inspect("a", "b", "f").must_equal %{<Result:true [1, nil, nil] >} }
+    # Edit returns End.fail_fast
+    it { update.(edit_return: Trailblazer::Operation::Railway.fail_fast!).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, nil] >} }
+  end
+
+  describe "Nested, no :fast_track option but all its outputs given" do
+    let(:update) do
+      Class.new(Trailblazer::Operation) do
+        include Steps
+
+        step task: Trailblazer::Operation::Callable( Edit, call: :call_with_circuit_interface ), id: "Callable/",
+          outputs: Edit.outputs  # all outputs given means it "works"
+        step :b
+        fail :f
+      end
+    end
+
+    # Edit returns End.success
+    it { update.(edit_return: true).inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >} }
+    # Edit returns End.failure
+    it { update.(edit_return: false).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, 3] >} }
+    # Edit returns End.pass_fast
+    it { update.(edit_return: Trailblazer::Operation::Railway.pass_fast!).inspect("a", "b", "f").must_equal %{<Result:true [1, nil, nil] >} }
+    # Edit returns End.fail_fast
+    it { update.(edit_return: Trailblazer::Operation::Railway.fail_fast!).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, nil] >} }
+  end
+
+  describe "2.0 behavior: no :fast_track option, all outputs given, but we rewire fast_track" do
+    let(:update) do
+      Class.new(Trailblazer::Operation) do
+        include Steps
+
+        step({task: Trailblazer::Operation::Callable( Edit, call: :call_with_circuit_interface ), id: "Callable/",
+                  outputs: Edit.outputs },
+          {Output(:pass_fast) => Track(:success), Output(:fail_fast) => Track(:failure)} )# manually rewire the fast-track outputs to "conventional" railway ends.
+
+        step :b
+        fail :f
+      end
+    end
+
+    # it { puts Trailblazer::Activity::Introspect.Cct(update.instance_variable_get(:@process)) }
+    it { update.to_h  }
+    # Edit returns End.success
+    it { update.(edit_return: true).inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >} }
+    # Edit returns End.failure
+    it { update.(edit_return: false).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, 3] >} }
+    # Edit returns End.pass_fast, but behaves like :success.
+    it { update.(edit_return: Trailblazer::Operation::Railway.pass_fast!).inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >} }
+    # Edit returns End.fail_fast, but behaves like :failure.
+    it { update.(edit_return: Trailblazer::Operation::Railway.fail_fast!).inspect("a", "b", "f").must_equal %{<Result:false [1, nil, 3] >} }
+  end
+end
+

data/test/gemfiles/Gemfile.ruby-2.0

@@ -1,6 +1,5 @@
 source 'https://rubygems.org'
 gemspec path: "../../"
 
-gem "declarative"
-gem "pipetree"
 gem "dry-container"
+gem "minitest-line"

data/test/gemfiles/Gemfile.ruby-2.0.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: ../..
+  specs:
+    trailblazer-operation (0.1.0)
+      declarative
+      trailblazer-activity (>= 0.1.3, < 0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.0.2)
+    declarative (0.0.9)
+    dry-configurable (0.4.0)
+      concurrent-ruby (~> 1.0)
+    dry-container (0.6.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+    hirb (0.7.3)
+    minitest (5.10.2)
+    minitest-line (0.6.3)
+      minitest (~> 5.0)
+    raise (0.0.2)
+    rake (12.0.0)
+    trailblazer-activity (0.1.3)
+      hirb
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  dry-container
+  minitest
+  minitest-line
+  raise
+  rake
+  trailblazer-operation!
+
+BUNDLED WITH
+   1.15.3

data/test/inheritance_test.rb

@@ -23,6 +23,6 @@ class InheritanceTest < Minitest::Spec
   it do
     Update["a"].must_equal "A"
     Update["b"].must_equal "B"
-    Update["c"].must_equal nil
+    Update["c"].must_be_nil
   end
 end

data/test/inspect_test.rb

@@ -0,0 +1,43 @@
+require "test_helper"
+
+
+class InspectTest < Minitest::Spec
+  # Test: #to_table
+  class Create < Trailblazer::Operation
+    step :decide!
+    pass :wasnt_ok!
+    pass :was_ok!
+    fail :return_true!
+    fail :return_false!
+    step :finalize!
+  end
+
+  #---
+  #- to_table
+
+  # pp Create.instance_variable_get(:@builder)
+
+  it do
+    Trailblazer::Operation.introspect(Create).must_equal %{[>decide!,>>wasnt_ok!,>>was_ok!,<<return_true!,<<return_false!,>finalize!]}
+  end
+
+  it do
+    Trailblazer::Operation::Inspect.call(Create, style: :rows).must_equal %{
+ 0 ==============================>decide!
+ 1 ===========================>>wasnt_ok!
+ 2 =============================>>was_ok!
+ 3 <<return_true!========================
+ 4 <<return_false!=======================
+ 5 ============================>finalize!}
+  end
+
+  describe "step with only one output (happens with Nested)" do
+    class Present < Trailblazer::Operation
+      pass :ok!, outputs: {:success => Trailblazer::Activity::Output("signal", :success)}
+    end
+
+    it do
+      Trailblazer::Operation.introspect(Present).must_equal %{[>>ok!]}
+    end
+  end
+end

data/test/introspect_test.rb

@@ -0,0 +1,51 @@
+require "test_helper"
+
+class IntrospectTest < Minitest::Spec
+  A = ->(*args) { [ Activity::Right, *args ] }
+  B = ->(*args) { [ Activity::Right, *args ] }
+  C = ->(*args) { [ Activity::Right, *args ] }
+  D = ->(*args) { [ Activity::Right, *args ] }
+
+  let(:activity) do
+    nested = bc
+
+    Class.new(Trailblazer::Operation) do
+      step A
+      step nested, Output(nested.outputs.keys.first, :success) => :success
+      step D, id: "D"
+    end
+  end
+
+  let(:bc) do
+    Class.new(Trailblazer::Operation) do
+      step B
+      step C
+    end
+  end
+
+  describe "#collect" do
+    it "iterates over each task element in the top activity" do
+      skip
+      all_tasks = Activity::Introspect.collect(activity) do |task, connections|
+        task
+      end
+
+      # pp all_tasks
+
+      all_tasks.size.must_equal 8
+      # all_tasks[1..3].must_equal [A, bc, D]
+      # TODO: test start and end!
+    end
+
+    it "iterates over all task elements recursively" do
+      skip
+      all_tasks = Activity::Introspect.collect(activity, recursive: true) do |task, connections|
+        task
+      end
+
+      all_tasks.size.must_equal 9
+      all_tasks[1..2].must_equal [A, bc]
+      all_tasks[4..5].must_equal [B, C]
+    end
+  end
+end

data/test/macro_test.rb

@@ -0,0 +1,60 @@
+require "test_helper"
+#- test
+# macro [ task, {name} ]
+# macro [ task, {name}, { alteration: } ] # see task_wrap_test.rb
+# macro [ task, {name}, { alteration: }, {task_outputs} ] # for eg. nested
+
+class MacroTest < Minitest::Spec
+  MacroB = ->(( options, *args ), **) do
+    options[:B] = true # we were here!
+
+    [ options[:MacroB_return], [ options, *args ] ]
+  end
+
+  it "raises exception when macro doesn't provide :id" do
+    assert_raises do
+
+      Class.new(Trailblazer::Operation) do
+        step( task: "<some macro>" )
+      end
+
+    end.message.must_equal %{No :id given for <some macro>}
+  end
+
+
+  class Create < Trailblazer::Operation
+    step :a
+    step task: MacroB, id: :MacroB, outputs: { :success => Activity::Output("Allgood", :success), :failure => Activity::Output("Fail!", :failure), :pass_fast => Activity::Output("Winning", :pass_fast) }
+    step :c
+
+    def a(options, **); options[:a] = true end
+    def c(options, **); options[:c] = true end
+  end
+
+  # MacroB returns Allgood and is wired to the :success edge (right track).
+  it { Create.( {}, MacroB_return: "Allgood" ).inspect(:a, :B, :c).must_equal %{<Result:true [true, true, true] >} }
+  # MacroB returns Fail! and is wired to the :failure edge (left track).
+  it { Create.( {}, MacroB_return: "Fail!" ).inspect(:a, :B, :c).must_equal %{<Result:false [true, true, nil] >} }
+  # MacroB returns Winning and is wired to the :pass_fast edge.
+  it { Create.( {}, MacroB_return: "Winning" ).inspect(:a, :B, :c).must_equal %{<Result:true [true, true, nil] >} }
+
+  #- user overrides :plus_poles
+  class Update < Trailblazer::Operation
+    macro = { task: MacroB, id: :MacroB, outputs: { :success => Activity::Output("Allgood", :success), :failure => Activity::Output("Fail!", :failure), :pass_fast => Activity::Output("Winning", :pass_fast) } }
+
+    step :a
+    step macro, outputs: { :success => Activity::Output("Fail!", :success), :fail_fast => Activity::Output("Winning", :fail_fast), :failure => Activity::Output("Allgood", :failure) }
+    # plus_poles: Test.plus_poles_for("Allgood" => :failure, "Fail!" => :success, "Winning" => :fail_fast)
+    step :c
+
+    def a(options, **); options[:a] = true end
+    def c(options, **); options[:c] = true end
+  end
+
+  # MacroB returns Allgood and is wired to the :failure edge.
+  it { Update.( {}, MacroB_return: "Allgood" ).inspect(:a, :B, :c).must_equal %{<Result:false [true, true, nil] >} }
+  # MacroB returns Fail! and is wired to the :success edge.
+  it { Update.( {}, MacroB_return: "Fail!" ).inspect(:a, :B, :c).must_equal %{<Result:true [true, true, true] >} }
+  # MacroB returns Winning and is wired to the :fail_fast edge.
+  it { Update.( {}, MacroB_return: "Winning" ).inspect(:a, :B, :c).must_equal %{<Result:false [true, true, nil] >} }
+end

data/test/operation_test.rb

@@ -0,0 +1,94 @@
+require "test_helper"
+
+class DeclarativeApiTest < Minitest::Spec
+  #---
+  #- step, pass, fail
+
+  # Test: step/pass/fail
+  # * do they deviate properly?
+  class Create < Trailblazer::Operation
+    step :decide!
+    pass :wasnt_ok!
+    pass :was_ok!
+    fail :return_true!
+    fail :return_false!
+
+    def decide!(options, decide:raise, **)
+      options["a"] = true
+      decide
+    end
+
+    def wasnt_ok!(options, **)
+      options["y"] = false
+    end
+
+    def was_ok!(options, **)
+      options["x"] = true
+    end
+
+    def return_true! (options, **); options["b"] = true end
+    def return_false!(options, **); options["c"] = false end
+  end
+
+  it { Create.(decide: true).inspect("a", "x", "y", "b", "c").must_equal %{<Result:true [true, true, false, nil, nil] >} }
+  it { Create.(decide: false).inspect("a", "x", "y", "b", "c").must_equal %{<Result:false [true, nil, nil, true, false] >} }
+
+  #---
+  #- trace
+
+  it do
+
+  end
+
+  #---
+  #- empty class
+  class Noop < Trailblazer::Operation
+  end
+
+  it { Noop.().inspect("params").must_equal %{<Result:true [nil] >} }
+
+  #---
+  #- pass
+  #- fail
+  class Update < Trailblazer::Operation
+    pass ->(options, **)         { options["a"] = false }
+    step ->(options, params:raise, **) { options["b"] = params[:decide] }
+    fail ->(options, **)         { options["c"] = true }
+  end
+
+  it { Update.("params" => {decide: true}).inspect("a", "b", "c").must_equal %{<Result:true [false, true, nil] >} }
+  it { Update.("params" => {decide: false}).inspect("a", "b", "c").must_equal %{<Result:false [false, false, true] >} }
+
+  #---
+  #- inheritance
+  class Upsert < Update
+    step ->(options, **) { options["d"] = 1 }
+  end
+
+  class Unset < Upsert
+    step ->(options, **) { options["e"] = 2 }
+  end
+
+  it "allows to inherit" do
+    Upsert.("params" => {decide: true}).inspect("a", "b", "c", "d", "e").must_equal %{<Result:true [false, true, nil, 1, nil] >}
+    Unset. ("params" => {decide: true}).inspect("a", "b", "c", "d", "e").must_equal %{<Result:true [false, true, nil, 1, 2] >}
+  end
+
+  describe "Activity::Interface" do
+    class Edit < Trailblazer::Operation
+      step :a
+      step :b, fast_track: true
+    end
+
+    it "provides #outputs" do
+      Activity::Introspect.Outputs(Edit.outputs).must_equal %{success=> (#<Trailblazer::Operation::Railway::End::Success semantic=:success>, success)
+failure=> (#<Trailblazer::Operation::Railway::End::Failure semantic=:failure>, failure)
+pass_fast=> (#<Trailblazer::Operation::Railway::End::PassFast semantic=:pass_fast>, pass_fast)
+fail_fast=> (#<Trailblazer::Operation::Railway::End::FailFast semantic=:fail_fast>, fail_fast)}
+    end
+
+    it "is an Interface" do
+      Edit.is_a?( Activity::Interface ).must_equal true
+    end
+  end
+end