trailblazer-operation 0.10.0 → 0.11.0

data/test/wiring/defaults_test.rb

@@ -1,193 +0,0 @@
-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) => Track(:success) # {}"End.success"
-    fail :c, Output(:success) => Track(: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 => Track(: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) => Id("End.success")
-    fail :c, Output(:success) => Id("End.success")
-    pass :d
-
-    Test.step(self, :a, :b, :c, :d)
-
-    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) => Id("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.decompose.first ) }
-
-  # 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) => Id("d"), id: "a"
-    fail :f, Output(:success) => Id("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
-
-  # 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

data/test/wiring/subprocess_test.rb

@@ -1,70 +0,0 @@
-# require "test_helper"
-
-# class WiringWithNestedTest < Minitest::Spec
-#   MyEnd = Class.new(Trailblazer::Circuit::End)
-
-#   class Create < Trailblazer::Operation
-#     class Edit < Trailblazer::Operation
-#       step :a
-
-#       def a(options, a_return:, **)
-#         options["a"] = 1
-#         a_return
-#       end
-
-#       # operations should expose their outputs with proper naming.
-#       #
-#       # {#<Trailblazer::Operation::Railway::End::Success:0x00000001b22310
-#       #   @name=:success,
-#       #   @options={}>=>{:role=>:success},
-#       #  #<Trailblazer::Operation::Railway::End::Failure:0x00000001b222c0
-#       #   @name=:failure,
-#       #   @options={}>=>{:role=>:unauthorized}}
-#       def self.outputs
-#         # Outputs::Only(super, :success, :failure)
-#         # Outputs::Update( outputs, failure: { role: :unauthorized}  )
-
-#         outs = super.to_a
-
-#         outs = Hash[*(outs[0]+outs[1])]
-
-#         outs.merge( outs.keys[1] => { role: :unauthorized } )
-#       end
-#     end
-
-#     attach MyEnd.new(:myend), id: "End.unauthorized"
-
-#     step ( { task: Trailblazer::Activity::Subprocess( Edit, call: :__call__ ),
-#       node_data:  { id: "Nested/" },
-#       outputs:    Edit.outputs, # THIS SHOULD OVERRIDE.
-#       connect_to: Merge({ unauthorized: "End.unauthorized" }) # connects :success automatically.
-#       }), fast_track: true
-
-#     step :b
-#     fail :f
-
-#     def b(options, a:, **)
-#       options["b"] = a+1
-#     end
-
-#     def f(options, a:, **)
-#       options["f"] = a+2
-#     end
-#   end
-
-#   # Edit ==> true, will run :b
-#   it do
-#     result = Create.({}, a_return: true )
-#     result.inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >}
-#     result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Success
-#   end
-
-#   # Edit ==> false, will end on End.unauthorized.
-#   it do
-#     result = Create.({}, a_return: false )
-#     result.inspect("a", "b", "f").must_equal %{<Result:false [1, nil, nil] >}
-#     result.event.must_be_instance_of MyEnd
-
-#     # Create.trace({}, a_return: false ).wtf
-#   end
-# end