trailblazer-macro 2.1.14 → 2.1.16

data/test/docs/pundit_test.rb

@@ -29,29 +29,29 @@ class DocsPunditProcTest < Minitest::Spec
   end
   #:pundit end
 
-  it { Trailblazer::Developer.railway(Create).must_equal %{[>model.build,>policy.default.eval]} }
-  it { Create.(params: {}, current_user: Module).inspect(:model).must_equal %{<Result:true [#<struct DocsPunditProcTest::Song id=nil>] >} }
-  it { Create.(params: {}                          ).inspect(:model).must_equal %{<Result:false [#<struct DocsPunditProcTest::Song id=nil>] >} }
+  it { assert_equal Trailblazer::Developer.railway(Create), %{[>model.build,>policy.default.eval]} }
+  it { assert_equal Create.(params: {}, current_user: Module).inspect(:model), %{<Result:true [#<struct DocsPunditProcTest::Song id=nil>] >} }
+  it { assert_equal Create.(params: {}).inspect(:model), %{<Result:false [#<struct DocsPunditProcTest::Song id=nil>] >} }
 
   it do
   #:pundit-result
-  result = Create.(params: {}, current_user: Module)
-  result[:"result.policy.default"].success? #=> true
-  result[:"result.policy.default"][:policy] #=> #<MyPolicy ...>
+    result = Create.(params: {}, current_user: Module)
+    result[:"result.policy.default"].success? #=> true
+    result[:"result.policy.default"][:policy] #=> #<MyPolicy ...>
   #:pundit-result end
-    result[:"result.policy.default"].success?.must_equal true
-    result[:"result.policy.default"][:policy].is_a?(MyPolicy).must_equal true
+    assert_equal result[:"result.policy.default"].success?, true
+    assert_equal result[:"result.policy.default"][:policy].is_a?(MyPolicy), true
   end
 
   #---
   #- override
   class New < Create
-    step Policy::Pundit( MyPolicy, :new? ), override: true
+    step Policy::Pundit( MyPolicy, :new? ), replace: :"policy.default.eval"
   end
 
-  it { Trailblazer::Developer.railway(New).must_equal %{[>model.build,>policy.default.eval]} }
-  it { New.(params: {}, current_user: Class ).inspect(:model).must_equal %{<Result:true [#<struct DocsPunditProcTest::Song id=nil>] >} }
-  it { New.(params: {}, current_user: nil ).inspect(:model).must_equal %{<Result:false [#<struct DocsPunditProcTest::Song id=nil>] >} }
+  it { assert_equal Trailblazer::Developer.railway(New), %{[>model.build,>policy.default.eval]} }
+  it { assert_equal New.(params: {}, current_user: Class ).inspect(:model), %{<Result:true [#<struct DocsPunditProcTest::Song id=nil>] >} }
+  it { assert_equal New.(params: {}, current_user: nil ).inspect(:model), %{<Result:false [#<struct DocsPunditProcTest::Song id=nil>] >} }
 
   #---
   #- override with :name
@@ -64,10 +64,10 @@ class DocsPunditProcTest < Minitest::Spec
     step Policy::Pundit( MyPolicy, :new?, name: "first" ), override: true
   end
 
-  it { Trailblazer::Developer.railway(Edit).must_equal %{[>policy.first.eval,>policy.second.eval]} }
-  it { Edit.(params: {}, current_user: Class).inspect(:model).must_equal %{<Result:false [nil] >} }
-  it { Trailblazer::Developer.railway(Update).must_equal %{[>policy.first.eval,>policy.second.eval]} }
-  it { Update.(params: {}, current_user: Class).inspect(:model).must_equal %{<Result:true [nil] >} }
+  it { assert_equal Trailblazer::Developer.railway(Edit), %{[>policy.first.eval,>policy.second.eval]} }
+  it { assert_equal Edit.(params: {}, current_user: Class).inspect(:model), %{<Result:false [nil] >} }
+  it { assert_equal Trailblazer::Developer.railway(Update), %{[>policy.first.eval,>policy.second.eval]} }
+  it { assert_equal Update.(params: {}, current_user: Class).inspect(:model), %{<Result:true [nil] >} }
 
   #---
   # dependency injection
@@ -85,7 +85,7 @@ class DocsPunditProcTest < Minitest::Spec
     :"policy.default.eval" => Trailblazer::Operation::Policy::Pundit.build(AnotherPolicy, :create?)
   )
   #:di-call end
-    result.inspect("").must_equal %{<Result:true [nil] >} }
+  assert_equal result.inspect(""), %{<Result:true [nil] >} }
 end
 
 #-
@@ -106,7 +106,7 @@ class PunditWithNameTest < Minitest::Spec
   result = Create.(params: {}, current_user: Module)
   result[:"result.policy.after_model"].success? #=> true
   #:name-call end
-    result[:"result.policy.after_model"].success?.must_equal true }
+  assert_equal result[:"result.policy.after_model"].success?, true }
 end
 
 #---
@@ -123,7 +123,7 @@ end
 #   #:class-level end
 
 #   it { Create.(); Create["result.policy"].must_be_nil }
-#   it { Create.(params: {}, current_user: Module)["x"].must_equal true }
+#   it { Create.(params: {}, current_user: Module)["x"], true }
 #   it { Create.(params: {}                          )["x"].must_be_nil }
 # end
 

data/test/docs/rescue_test.rb

@@ -23,18 +23,18 @@ class NestedRescueTest < Minitest::Spec
     fail ->(options, **) { options["outer-err"] = true }, id: "nested/failure"
   end
 
-  it { Trailblazer::Developer.railway(NestedInsanity).must_match /\[>Rescue\(.{8}\),>nested/ } # FIXME: better introspect tests for all id-generating macros.
-  it { NestedInsanity.().inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
-  it { NestedInsanity.( "raise-y" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, nil, nil, nil, nil, true, true] >} }
-  it { NestedInsanity.( "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
+  it { assert_match /\[>Rescue\/.{1,3},>nested/, Trailblazer::Developer.railway(NestedInsanity)  } # FIXME: better introspect tests for all id-generating macros.
+  it { assert_equal NestedInsanity.().inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err"), %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
+  it { assert_equal NestedInsanity.( "raise-y" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err"), %{<Result:false [true, true, nil, nil, nil, nil, true, true] >} }
+  it { assert_equal NestedInsanity.( "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err"), %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
 
   #-
   # inheritance
   class UbernestedInsanity < NestedInsanity
   end
 
-  it { UbernestedInsanity.().inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
-  it { UbernestedInsanity.( "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
+  it { assert_equal UbernestedInsanity.().inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err"), %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
+  it { assert_equal UbernestedInsanity.( "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err"), %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
 end
 
 class RescueTest < Minitest::Spec
@@ -43,31 +43,37 @@ class RescueTest < Minitest::Spec
 plain Rescue()
 =end
   class RescueWithoutHandlerTest < Minitest::Spec
-    Memo = Class.new
+    Song = Class.new
+    module Song::Activity; end
 
-    class Memo::Create < Trailblazer::Operation
-      step :find_model
+    #:no-args
+    class Song::Activity::Create < Trailblazer::Activity::Railway
+      step :create_model
       step Rescue() {
-        step :update
+        step :upload
         step :rehash
       }
       step :notify
       fail :log_error
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:create_model, :upload, :notify, :log_error)
       include Rehash
       #~methods end
     end
+    #:no-args end
 
-    it { Memo::Create.( { seq: [] } ).inspect(:seq, :exception_class).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify], nil] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error]] >} }
+    it { assert_invoke Song::Activity::Create, seq: "[:create_model, :upload, :rehash, :notify]" }
+    it { assert_invoke Song::Activity::Create, rehash_raise: RuntimeError, terminus: :failure, seq: "[:create_model, :upload, :rehash, :log_error]", exception_class: RuntimeError }
+    it { assert_invoke Song::Activity::Create, rehash_raise: :bla, terminus: :failure, seq: "[:create_model, :upload, :rehash, :log_error]", exception_class: :bla }
+    it { assert_invoke Song::Activity::Create, rehash_raise: NoMethodError, terminus: :failure, seq: "[:create_model, :upload, :rehash, :log_error]", exception_class: NoMethodError }
   end
 
 =begin
-Rescue( handler: X )
+Rescue( SPECIFIC_EXCEPTION, handler: X )
 =end
   class RescueWithClassHandlerTest < Minitest::Spec
-    Memo = Class.new
+    Song = Class.new
+    module Song::Activity; end
 
     #:rescue-handler
     class MyHandler
@@ -78,23 +84,29 @@ Rescue( handler: X )
     #:rescue-handler end
 
     #:rescue
-    class Memo::Create < Trailblazer::Operation
-      step :find_model
-      step Rescue( RuntimeError, handler: MyHandler ) {
-        step :update
+    class Song::Activity::Create < Trailblazer::Activity::Railway
+      step :create_model
+      step Rescue(RuntimeError, handler: MyHandler) {
+        step :upload
         step :rehash
       }
       step :notify
       fail :log_error
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:create_model, :upload, :notify, :log_error)
       include Rehash
       #~methods end
     end
     #:rescue end
 
-    it { Memo::Create.( { seq: [], } ).inspect(:seq, :exception_class).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify], nil] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq, :exception_class).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error], RuntimeError] >} }
+    it { assert_invoke Song::Activity::Create, seq: "[:create_model, :upload, :rehash, :notify]" }
+    it { assert_invoke Song::Activity::Create, rehash_raise: RuntimeError, terminus: :failure, seq: "[:create_model, :upload, :rehash, :log_error]", exception_class: RuntimeError }
+    it do
+      # Since we don't catch NoMethodError, execution stops.
+      assert_raises NoMethodError do
+        Song::Activity::Create.invoke([{seq: {}, rehash_raise: NoMethodError}])
+      end
+    end
   end
 
   class RescueWithModuleHandlerTest < Minitest::Spec
@@ -118,8 +130,8 @@ Rescue( handler: X )
       include Rehash
     end
 
-    it { Memo::Create.( { seq: [], } ).inspect(:seq, :exception_class).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify], nil] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq, :exception_class).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error], RuntimeError] >} }
+    it { assert_equal Memo::Create.( { seq: [], } ).inspect(:seq, :exception_class), %{<Result:true [[:find_model, :update, :rehash, :notify], nil] >} }
+    it { assert_equal Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq, :exception_class), %{<Result:false [[:find_model, :update, :rehash, :log_error], RuntimeError] >} }
   end
 
 =begin
@@ -148,8 +160,8 @@ Rescue( handler: :instance_method )
     end
     #:rescue-method end
 
-    it { Memo::Create.( { seq: [], } ).inspect(:seq, :exception_class).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify], nil] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq, :exception_class).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error], RuntimeError] >} }
+    it { assert_equal Memo::Create.( { seq: [], } ).inspect(:seq, :exception_class), %{<Result:true [[:find_model, :update, :rehash, :notify], nil] >} }
+    it { assert_equal Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq, :exception_class), %{<Result:false [[:find_model, :update, :rehash, :log_error], RuntimeError] >} }
   end
 
 =begin
@@ -173,7 +185,67 @@ Rescue(), fast_track: true {}
       include T.def_steps(:find_model, :update, :notify, :log_error, :rehash)
     end
 
-    it { Memo::Create.( { seq: [], } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], update: false } ).inspect(:seq).must_equal %{<Result:false [[:find_model, :update]] >} }
+    it { assert_equal Memo::Create.( { seq: [], } ).inspect(:seq), %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
+    it { assert_equal Memo::Create.( { seq: [], update: false } ).inspect(:seq), %{<Result:false [[:find_model, :update]] >} }
+  end
+
+  class RescueIDTest < Minitest::Spec
+    class Validate
+      def self.call(*)
+
+      end
+    end
+
+    it "assigns ID via {Macro.id_for}" do
+      activity = Class.new(Trailblazer::Activity::Railway) do
+        step Rescue() {}
+        step Rescue(handler: Validate) {}
+        step Rescue(handler: :instance_method) {}
+        step Rescue() {}, id: "Rescue-1"
+        step Rescue(id: "Rescue-2") {}
+        # test identical configuration.
+        step Rescue() {}
+        step Rescue(handler: Validate) {}
+      end
+
+      # assert_equal Trailblazer::Developer::Introspect.find_path(activity, ["Each/EachIDTest::Validate"])[0].id, "Each/EachIDTest::Validate"
+      # assert_equal Trailblazer::Developer::Introspect.find_path(activity, ["Each-1"])[0].id,                    "Each-1"
+      # assert_equal Trailblazer::Developer::Introspect.find_path(activity, ["Each/composers_for_each"])[0].id,   "Each/composers_for_each"
+
+      assert_match (/Rescue\/\d+/), Trailblazer::Activity::Introspect::Nodes(activity).values[1].id
+      assert_match (/Rescue\/\d+/), Trailblazer::Activity::Introspect::Nodes(activity).values[2].id
+      assert_match (/Rescue\/\d+/), Trailblazer::Activity::Introspect::Nodes(activity).values[3].id
+      assert_equal "Rescue-1", Trailblazer::Activity::Introspect::Nodes(activity).values[4].id
+      assert_equal "Rescue-2", Trailblazer::Activity::Introspect::Nodes(activity).values[5].id
+      assert_match (/Rescue\/\d+/), Trailblazer::Activity::Introspect::Nodes(activity).values[6].id
+      assert_match (/Rescue\/\d+/), Trailblazer::Activity::Introspect::Nodes(activity).values[7].id
+    end
+  end
+
+  class ComplianceTest < Minitest::Spec
+    it "tracing" do
+      activity = Class.new(Trailblazer::Activity::Railway) do
+        step Rescue(id: "Rescue/1") {
+          step :validate
+        }
+
+        def validate(ctx, validate: false, seq:, **)
+          seq << :validate
+          raise unless validate
+          validate
+        end
+      end
+
+      ctx = {validate: false}
+
+      output, _ = trace activity, ctx
+
+      assert_equal output, %(TOP
+|-- Start.default
+|-- Rescue/1
+|   |-- Start.default
+|   `-- validate
+`-- End.failure)
+    end
   end
 end

data/test/docs/wrap_test.rb

@@ -169,9 +169,9 @@ When raise:   return {Railway.fail!}
   #@ happy days
     assert_invoke Memo::Create, seq: "[:model, :update, :rehash, :notify]"
   #@ rehash raises
-    assert_invoke Memo::Create, rehash_raise: true, seq: "[:model, :update, :rehash, :log_error]",
+    assert_invoke Memo::Create, rehash_raise: RuntimeError, seq: "[:model, :update, :rehash, :log_error]",
       terminus: :failure,
-      expected_ctx_variables: {exception: "nope!"}
+      expected_ctx_variables: {exception: "RuntimeError"}
   end
 
 =begin
@@ -204,8 +204,8 @@ When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
       #~methods end
     end
 
-    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >} }
+    it { assert_equal Memo::Create.( { seq: [] } ).inspect(:seq), %{<Result:true [[:model, :update, :rehash, :notify]] >} }
+    it { assert_equal Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq), %{<Result:false [[:model, :update, :rehash]] >} }
   end
 
 =begin
@@ -241,8 +241,8 @@ When raise:   return {Railway.fail_fast!} and configure Wrap() to {fast_track: t
     end
     #:fail-fast end
 
-    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >} }
+    it { assert_equal Memo::Create.( { seq: [] } ).inspect(:seq), %{<Result:true [[:model, :update, :rehash, :notify]] >} }
+    it { assert_equal Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq), %{<Result:false [[:model, :update, :rehash]] >} }
   end
 
 =begin
@@ -284,14 +284,16 @@ When raise:   return {Railway.fail!} or {Railway.pass!}
 
     it do
       result = Memo::Create.( { seq: [] } )
-      result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_worked>}
+
+      assert_equal result.inspect(:seq), %{<Result:false [[:model, :update, :rehash]] >}
+      assert_equal result.event.inspect, %{#<Trailblazer::Activity::End semantic=:transaction_worked>}
     end
 
     it do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
-      result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_failed>}
+      result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
+
+      assert_equal result.inspect(:seq), %{<Result:false [[:model, :update, :rehash]] >}
+      assert_equal result.event.inspect, %{#<Trailblazer::Activity::End semantic=:transaction_failed>}
     end
   end
 
@@ -325,8 +327,8 @@ When raise:   return {Railway.pass!} and go "successful"
       #~methods end
     end
 
-    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
+    it { assert_equal Memo::Create.( { seq: [] } ).inspect(:seq), %{<Result:true [[:model, :update, :rehash, :notify]] >} }
+    it { assert_equal Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq), %{<Result:true [[:model, :update, :rehash, :notify]] >} }
   end
 
 =begin
@@ -361,9 +363,10 @@ You can return boolean true in wrap.
     end
 
     it "translates true returned form a wrap to a signal with a `success` semantic" do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
-      result.inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
+      result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
+
+      assert_equal result.inspect(:seq), %{<Result:true [[:model, :update, :rehash, :notify]] >}
+      assert_equal result.event.inspect, %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
     end
   end
 
@@ -399,9 +402,10 @@ You can return boolean false in wrap.
     end
 
     it "translates false returned form a wrap to a signal with a `failure` semantic" do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
-      result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+      result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
+
+      assert_equal result.inspect(:seq), %{<Result:false [[:model, :update, :rehash, :log_error]] >}
+      assert_equal result.event.inspect, %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
     end
   end
 
@@ -437,9 +441,10 @@ You can return nil in wrap.
     end
 
     it "translates nil returned form a wrap to a signal with a `failure` semantic" do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
-      result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+      result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
+
+      assert_equal result.inspect(:seq), %{<Result:false [[:model, :update, :rehash, :log_error]] >}
+      assert_equal result.event.inspect, %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
     end
   end
 
@@ -453,7 +458,7 @@ This one is mostly to show how one could wrap steps in a transaction
 
     module Sequel
       def self.transaction
-        end_event, (ctx, flow_options) = yield
+        _end_event, (_ctx, _flow_options) = yield
       end
     end
 
@@ -483,8 +488,8 @@ This one is mostly to show how one could wrap steps in a transaction
     end
     #:transaction end
 
-    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >} }
+    it { assert_equal Memo::Create.( { seq: [] } ).inspect(:seq), %{<Result:true [[:model, :update, :rehash, :notify]] >} }
+    it { assert_equal Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq), %{<Result:false [[:model, :update, :rehash, :log_error]] >} }
   end
 
 =begin
@@ -523,8 +528,8 @@ This one is mostly to show how one could evaluate Wrap()'s return value based on
     end
     #:transaction end
 
-    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update]] >} }
-    it { Memo::Create.( { seq: [], update: false } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :log_error]] >} }
+    it { assert_equal Memo::Create.( { seq: [] } ).inspect(:seq), %{<Result:true [[:model, :update]] >} }
+    it { assert_equal Memo::Create.( { seq: [], update: false } ).inspect(:seq), %{<Result:false [[:model, :update, :log_error]] >} }
   end
 
 
@@ -661,6 +666,19 @@ class WrapUnitTest < Minitest::Spec
 
     #@ the patched version only runs {mock_validation}.
     assert_invoke patched_activity, seq: %{[:mock_validation]}
+
+    # Patch Wrap/Subprocess/step, put step after {validate}
+    patched_activity = Trailblazer::Activity::DSL::Linear::Patch.call(
+      activity,
+      ["Wrap/WrapUnitTest::HandleUnsafeProcess", :validation],
+      -> { step mock_validation }
+    )
+
+    #@ the original activity with Wrap is unchanged.
+    assert_invoke activity, seq: %{[:validate]}
+
+    #@ the patched version only runs {mock_validation}.
+    assert_invoke patched_activity, seq: %{[:validate, :mock_validation]}
   end
 end
 

data/test/operation/integration_test.rb

@@ -30,12 +30,12 @@ class IntegrationTest < Minitest::Spec
   end
 
   class SongSpecialCreate < Trailblazer::Operation
-    step Nested(ArtistCreate)
-    step Nested(SongCreate)
+    step Subprocess(ArtistCreate)
+    step Subprocess(SongCreate)
   end
 
   it "create Artist and Song" do
-    result = SongSpecialCreate.trace(
+    result = SongSpecialCreate.wtf?(
       params: {
         artist: {
           name: "My Artist"
@@ -46,10 +46,8 @@ class IntegrationTest < Minitest::Spec
       }
     )
 
-    puts result.wtf?
-
     # this should return song
-    result[:model].name.must_match "My Song"
-    result[:model].artist_name.must_match "My Artist"
+    assert_equal result[:model].name, "My Song"
+    assert_equal result[:model].artist_name, "My Artist"
   end
 end

data/test/operation/pundit_test.rb

@@ -27,23 +27,24 @@ class PolicyTest < Minitest::Spec
   # successful.
   it do
     result = Create.(params: {}, current_user: Module)
-    result[:process].must_equal true
+
+    assert_equal result[:process], true
     #- result object, policy
-    result[:"result.policy.default"].success?.must_equal true
-    result[:"result.policy.default"][:message].must_be_nil
+    assert_equal result[:"result.policy.default"].success?, true
+    assert_nil result[:"result.policy.default"][:message]
     # result[:valid].must_be_nil
-    result[:"policy.default"].inspect.must_equal %{<Auth: user:Module, model:nil>}
+    assert_equal result[:"policy.default"].inspect, %{<Auth: user:Module, model:nil>}
   end
   # breach.
   it do
     result = Create.(params: {}, current_user: nil)
-    result[:process].must_be_nil
+    assert_nil result[:process]
     #- result object, policy
-    result[:"result.policy.default"].success?.must_equal false
-    result[:"result.policy.default"][:message].must_equal "Breach"
+    assert_equal result[:"result.policy.default"].success?, false
+    assert_equal result[:"result.policy.default"][:message], "Breach"
   end
-  # inject different policy.Condition  it { Create.(params: {}, current_user: Object, "policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_object?))["process"].must_equal true }
-  it { Create.(params: {}, current_user: Module, :"policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_object?))[:process].must_be_nil }
+  # inject different policy.Condition  it { Create.(params: {}, current_user: Object, "policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_object?))["process"], true }
+  it { assert_nil Create.(params: {}, current_user: Module, :"policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_object?))[:process] }
 
 
   #---
@@ -52,23 +53,25 @@ class PolicyTest < Minitest::Spec
     step Model( Song, :new ), before: :"policy.default.eval"
   end
 
-  it { Trailblazer::Developer.railway(Show).must_equal %{[>model.build,>policy.default.eval,>process]} }
+  it { assert_equal Trailblazer::Developer.railway(Show), %{[>model.build,>policy.default.eval,>process]} }
 
   # invalid because user AND model.
   it do
     result = Show.(params: {}, current_user: Module)
-    result[:process].must_be_nil
-    result[:model].inspect.must_equal %{#<struct PolicyTest::Song id=nil>}
-    # result["policy"].inspect.must_equal %{#<struct PolicyTest::Song id=nil>}
+    assert_nil result[:process]
+
+    assert_equal result[:model].inspect, %{#<struct PolicyTest::Song id=nil>}
+    # result["policy"].inspect, %{#<struct PolicyTest::Song id=nil>}
   end
 
   # valid because new policy.
   it do
     # puts Show["pipetree"].inspect
     result = Show.(params: {}, current_user: Module, :"policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_and_model?))
-    result[:process].must_equal true
-    result[:model].inspect.must_equal %{#<struct PolicyTest::Song id=nil>}
-    result[:"policy.default"].inspect.must_equal %{<Auth: user:Module, model:#<struct PolicyTest::Song id=nil>>}
+
+    assert_equal result[:process], true
+    assert_equal result[:model].inspect, %{#<struct PolicyTest::Song id=nil>}
+    assert_equal result[:"policy.default"].inspect, %{<Auth: user:Module, model:#<struct PolicyTest::Song id=nil>>}
   end
 
   ##--
@@ -86,20 +89,23 @@ class PolicyTest < Minitest::Spec
   # successful.
   it do
     result = Edit.(params: { id: 1 }, current_user: Module)
-    result[:process].must_equal true
-    result[:model].inspect.must_equal %{#<struct PolicyTest::Song id=1>}
-    result[:"result.policy.default"].success?.must_equal true
-    result[:"result.policy.default"][:message].must_be_nil
+
+    assert_equal result[:process], true
+    assert_equal result[:model].inspect, %{#<struct PolicyTest::Song id=1>}
+    assert_equal result[:"result.policy.default"].success?, true
+    assert_nil result[:"result.policy.default"][:message]
     # result[:valid].must_be_nil
-    result[:"policy.default"].inspect.must_equal %{<Auth: user:Module, model:#<struct PolicyTest::Song id=1>>}
+    assert_equal result[:"policy.default"].inspect, %{<Auth: user:Module, model:#<struct PolicyTest::Song id=1>>}
   end
 
   # breach.
   it do
     result = Edit.(params: { id: 4 }, current_user: nil)
-    result[:model].inspect.must_equal %{#<struct PolicyTest::Song id=4>}
-    result[:process].must_be_nil
-    result[:"result.policy.default"].success?.must_equal false
-    result[:"result.policy.default"][:message].must_equal "Breach"
+
+    assert_equal result[:model].inspect, %{#<struct PolicyTest::Song id=4>}
+    assert_nil result[:process]
+
+    assert_equal result[:"result.policy.default"].success?, false
+    assert_equal result[:"result.policy.default"][:message], "Breach"
   end
 end

data/test/test_helper.rb

@@ -17,7 +17,7 @@ end
 module Rehash
   def rehash(ctx, seq:, rehash_raise: false, **)
     seq << :rehash
-    raise "nope!" if rehash_raise
+    raise rehash_raise if rehash_raise
     true
   end
 end
@@ -27,6 +27,13 @@ Minitest::Spec.include Trailblazer::Activity::Testing::Assertions
 Minitest::Spec.class_eval do
   def trace(activity, ctx)
     stack, signal, (ctx, _) = Trailblazer::Developer::Trace.invoke(activity, [ctx, {}])
-    return Trailblazer::Developer::Trace::Present.(stack, node_options: {stack.to_a[0]=>{label: "TOP"}}).gsub(/:\d+/, ""), signal, ctx
+
+    output = Trailblazer::Developer::Trace::Present.(stack) do |trace_nodes:, **|
+      {node_options: {trace_nodes[0] => {label: "TOP"}}}
+    end.gsub(/:\d+/, "")
+
+    return output, signal, ctx
   end
 end
+
+# Trailblazer::Core.convert_operation_test("test/docs/composable_variable_mapping_test.rb")

data/trailblazer-macro.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "trailblazer-developer"
-  spec.add_dependency "trailblazer-operation", ">= 0.10.0" # TODO: this dependency will be removed. currently needed for tests and for Guard::Result
+  spec.add_development_dependency "trailblazer-developer", ">= 0.1.0", "< 0.2.0"
+  spec.add_dependency "trailblazer-operation", ">= 0.10.1" # TODO: this dependency will be removed. currently needed for tests and for Guard::Result
 
   spec.add_dependency "trailblazer-activity-dsl-linear", ">= 1.2.0", "< 1.3.0"