trailblazer-operation 0.4.1 → 0.6.0

data/test/inspect_test.rb

@@ -1,43 +0,0 @@
-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/macro_test.rb

@@ -1,60 +0,0 @@
-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/task_wrap_test.rb

@@ -1,97 +0,0 @@
-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",
-
-      Trailblazer::Activity::DSL::Extension.new(
-        Trailblazer::Activity::TaskWrap::Merge.new(
-          Module.new do
-            extend Trailblazer::Activity::Path::Plan()
-
-            task Trailblazer::Operation::Wrap::Inject::ReverseMergeDefaults.new( contract: "MyDefaultContract" ),
-              id:     "inject.my_default",
-              before: "task_wrap.call_task"
-          end
-        )
-      ) => true
-    )
-
-    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
-    result = Create.call( {} )
-
-    inspect_hash(result, "options.contract", :contract, "MyMacro.contract").
-      must_equal %{{"options.contract"=>nil, :contract=>"MyDefaultContract", "MyMacro.contract"=>"MyDefaultContract"}}
-  end
-
-  # injected from outside, Injection skips.
-  it do
-    result = Create.call( { :contract=>"MyExternalContract" } )
-
-    inspect_hash(result, "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), circuit_options ) {
-          _d, *o = Create.call( [ options, *args ], circuit_options )
-
-          [ Trailblazer::Activity::Right, *o ]
-        },
-      id: "Create"
-    )
-    step(
-      task:           AnotherMacro,
-      id:             "AnotherMacro",
-      Trailblazer::Activity::DSL::Extension.new(
-        Trailblazer::Activity::TaskWrap::Merge.new(
-          Module.new do
-            extend Trailblazer::Activity::Path::Plan()
-
-            task Trailblazer::Operation::Wrap::Inject::ReverseMergeDefaults.new( another_contract: "AnotherDefaultContract" ), id: "inject.my_default",
-            before: "task_wrap.call_task"
-          end
-        )
-      ) => true,
-    )
-  end
-
-  it do
-    result = Update.call( {} )
-
-    inspect_hash(result, "options.contract", :contract, "MyMacro.contract", "AnotherMacro.another_contract").
-      must_equal %{{"options.contract"=>nil, :contract=>"MyDefaultContract", "MyMacro.contract"=>"MyDefaultContract", "AnotherMacro.another_contract"=>"AnotherDefaultContract"}}
-  end
-end