trailblazer-macro 2.1.15 → 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\/.{1,3},>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
@@ -130,8 +130,8 @@ Rescue( SPECIFIC_EXCEPTION, 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: RuntimeError } ).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
@@ -160,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: RuntimeError } ).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
@@ -185,8 +185,8 @@ 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
@@ -212,13 +212,13 @@ Rescue(), fast_track: true {}
       # 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_match "Rescue-1", Trailblazer::Activity::Introspect::Nodes(activity).values[4].id
-      assert_match "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
+      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
 
@@ -239,6 +239,7 @@ Rescue(), fast_track: true {}
       ctx = {validate: false}
 
       output, _ = trace activity, ctx
+
       assert_equal output, %(TOP
 |-- Start.default
 |-- Rescue/1

data/test/docs/wrap_test.rb

@@ -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: RuntimeError } ).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: RuntimeError } ).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: RuntimeError } )
-      result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_failed>}
+
+      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: RuntimeError } ).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
@@ -362,8 +364,9 @@ You can return boolean true in wrap.
 
     it "translates true returned form a wrap to a signal with a `success` semantic" do
       result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
-      result.inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
+
+      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
 
@@ -400,8 +403,9 @@ You can return boolean false in wrap.
 
     it "translates false returned form a wrap to a signal with a `failure` semantic" do
       result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
-      result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+
+      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
 
@@ -438,8 +442,9 @@ You can return nil in wrap.
 
     it "translates nil returned form a wrap to a signal with a `failure` semantic" do
       result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
-      result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+
+      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: RuntimeError } ).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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-macro
 version: !ruby/object:Gem::Version
-  version: 2.1.15
+  version: 2.1.16
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-14 00:00:00.000000000 Z
+date: 2024-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -111,6 +111,7 @@ files:
 - lib/trailblazer/macro/each.rb
 - lib/trailblazer/macro/guard.rb
 - lib/trailblazer/macro/model.rb
+- lib/trailblazer/macro/model/find.rb
 - lib/trailblazer/macro/nested.rb
 - lib/trailblazer/macro/policy.rb
 - lib/trailblazer/macro/pundit.rb
@@ -123,6 +124,7 @@ files:
 - test/docs/each_test.rb
 - test/docs/guard_test.rb
 - test/docs/macro_test.rb
+- test/docs/model/find_test.rb
 - test/docs/model_test.rb
 - test/docs/nested_static_test.rb
 - test/docs/pundit_test.rb
@@ -161,6 +163,7 @@ test_files:
 - test/docs/each_test.rb
 - test/docs/guard_test.rb
 - test/docs/macro_test.rb
+- test/docs/model/find_test.rb
 - test/docs/model_test.rb
 - test/docs/nested_static_test.rb
 - test/docs/pundit_test.rb