test/docs/wrap_test.rb in trailblazer-macro-2.1.14 vs test/docs/wrap_test.rb in trailblazer-macro-2.1.15

@@ -167,13 +167,13 @@
 
   it do
   #@ 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
 When success: return the block's returns
 When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
@@ -203,11 +203,11 @@
       include Rehash
       #~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 { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >} }
   end
 
 =begin
 When success: return the block's returns
 When raise:   return {Railway.fail_fast!} and configure Wrap() to {fast_track: true}
@@ -240,11 +240,11 @@
       #~methods end
     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 { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >} }
   end
 
 =begin
 When success: return the block's returns
 When raise:   return {Railway.fail!} or {Railway.pass!}
@@ -287,11 +287,11 @@
       result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_worked>}
     end
 
     it do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      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>}
     end
   end
 
@@ -324,11 +324,11 @@
       include Rehash
       #~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 { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
   end
 
 =begin
 When success: return the block's returns
 When raise:   return {true} and go "successful"
@@ -359,11 +359,11 @@
       include Rehash
       #~methods end
     end
 
     it "translates true returned form a wrap to a signal with a `success` semantic" do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      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>}
     end
   end
 
@@ -397,11 +397,11 @@
       include Rehash
       #~methods end
     end
 
     it "translates false returned form a wrap to a signal with a `failure` semantic" do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      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>}
     end
   end
 
@@ -435,11 +435,11 @@
       include Rehash
       #~methods end
     end
 
     it "translates nil returned form a wrap to a signal with a `failure` semantic" do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      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>}
     end
   end
 
@@ -482,10 +482,10 @@
       #~methods end
     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 { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >} }
   end
 
 =begin
 When success: return {Railway.pass_fast!}
 When failure: return {Railway.fail!}