trailblazer 2.0.7 → 2.1.0.beta1

data/test/docs/contract_test.rb

@@ -7,6 +7,7 @@ class DocsContractOverviewTest < Minitest::Spec
   # app/concepts/song/create.rb
   class Create < Trailblazer::Operation
     #~bla
+    extend ClassDependencies
     extend Contract::DSL
 
     contract do
@@ -29,16 +30,15 @@ class DocsContractOverviewTest < Minitest::Spec
   end
   #:overv-reform end
 
-  puts Create["pipetree"].inspect(style: :rows)
+  puts Trailblazer::Operation::Inspect.(Create, style: :rows)
 
 =begin
   #:overv-reform-pipe
-   0 =======================>>operation.new
-   1 ==========================&model.build
-   2 =======================>contract.build
-   3 ==============&validate.params.extract
-   4 ====================&contract.validate
-   5 =========================&persist.save
+   0 ==========================&model.build
+   1 =======================>contract.build
+   2 ==============&validate.params.extract
+   3 ====================&contract.validate
+   4 =========================&persist.save
   #:overv-reform-pipe end
 =end
 
@@ -49,7 +49,7 @@ class DocsContractOverviewTest < Minitest::Spec
   #- result
   it do
     #:result
-    result = Create.({ length: "A" })
+    result = Create.(params: { length: "A" })
 
     result["result.contract.default"].success?        #=> false
     result["result.contract.default"].errors          #=> Errors object
@@ -59,6 +59,19 @@ class DocsContractOverviewTest < Minitest::Spec
     result["result.contract.default"].success?.must_equal false
     result["result.contract.default"].errors.messages.must_equal ({:title=>["can't be blank"], :length=>["is not a number"]})
   end
+
+  it "shows 2-level tracing" do
+    result = Create.trace( params: { length: "A" } )
+    result.wtf.gsub(/0x\w+/, "").must_equal %{|-- #<Trailblazer::Activity::Start:>
+|-- model.build
+|-- contract.build
+|-- contract.default.validate
+|   |-- #<Trailblazer::Activity::Start:>
+|   |-- contract.default.params_extract
+|   |-- contract.default.call
+|   `-- #<Trailblazer::Activity::End:>
+`-- #<Trailblazer::Operation::Railway::End::Failure:>}
+  end
 end
 
 class DocsContractNameTest < Minitest::Spec
@@ -131,6 +144,7 @@ class DocsContractSeparateKeyTest < Minitest::Spec
   Song = Struct.new(:id, :title)
   #:key-extr
   class Create < Trailblazer::Operation
+    extend ClassDependencies
     extend Contract::DSL
 
     contract do
@@ -147,14 +161,14 @@ class DocsContractSeparateKeyTest < Minitest::Spec
     step Contract::Validate( skip_extract: true )
     step Contract::Persist( method: :sync )
 
-    def extract_params!(options)
-      options["contract.default.params"] = options["params"][type]
+    def extract_params!(options, **)
+      options["contract.default.params"] = options[:params][type]
     end
   end
   #:key-extr end
 
-  it { Create.({ }).inspect("model").must_equal %{<Result:false [#<struct DocsContractSeparateKeyTest::Song id=nil, title=nil>] >} }
-  it { Create.({"evergreen" => { title: "SVG" }}).inspect("model").must_equal %{<Result:true [#<struct DocsContractSeparateKeyTest::Song id=nil, title="SVG">] >} }
+  it { Create.(params: { }).inspect(:model).must_equal %{<Result:false [#<struct DocsContractSeparateKeyTest::Song id=nil, title=nil>] >} }
+  it { Create.(params: {"evergreen" => { title: "SVG" }}).inspect(:model).must_equal %{<Result:true [#<struct DocsContractSeparateKeyTest::Song id=nil, title="SVG">] >} }
 end
 
 #---
@@ -188,18 +202,18 @@ class ContractConstantTest < Minitest::Spec
   end
   #:constant end
 
-  it { Song::Create.({ title: "A" }).inspect("model").must_equal %{<Result:false [#<struct ContractConstantTest::Song title=nil, length=nil>] >} }
-  it { Song::Create.({ title: "Anthony's Song", length: 12 }).inspect("model").must_equal %{<Result:true [#<struct ContractConstantTest::Song title="Anthony's Song", length=12>] >} }
+  it { Song::Create.(params: { title: "A" }).inspect(:model).must_equal %{<Result:false [#<struct ContractConstantTest::Song title=nil, length=nil>] >} }
+  it { Song::Create.(params: { title: "Anthony's Song", length: 12 }).inspect(:model).must_equal %{<Result:true [#<struct ContractConstantTest::Song title="Anthony's Song", length=12>] >} }
   it do
     #:constant-result
-    result = Song::Create.( title: "A" )
+    result = Song::Create.(params: { title: "A" })
     result.success? #=> false
     result["contract.default"].errors.messages
       #=> {:title=>["is too short (minimum is 2 characters)"], :length=>["is not a number"]}
     #:constant-result end
 
     #:constant-result-true
-    result = Song::Create.( title: "Rising Force", length: 13 )
+    result = Song::Create.(params: { title: "Rising Force", length: 13 })
     result.success? #=> true
     result["model"] #=> #<Song title="Rising Force", length=13>
     #:constant-result-true end
@@ -214,11 +228,11 @@ class ContractConstantTest < Minitest::Spec
   end
   #:constant-new end
 
-  it { Song::New.().inspect("model").must_equal %{<Result:true [#<struct ContractConstantTest::Song title=nil, length=nil>] >} }
-  it { Song::New.()["contract.default"].model.inspect.must_equal %{#<struct ContractConstantTest::Song title=nil, length=nil>} }
+  it { Song::New.(params: {}).inspect(:model).must_equal %{<Result:true [#<struct ContractConstantTest::Song title=nil, length=nil>] >} }
+  it { Song::New.(params: {})["contract.default"].model.inspect.must_equal %{#<struct ContractConstantTest::Song title=nil, length=nil>} }
   it do
     #:constant-new-result
-    result = Song::New.()
+    result = Song::New.(params: {})
     result["model"] #=> #<struct Song title=nil, length=nil>
     result["contract.default"]
       #=> #<Song::Contract::Create model=#<struct Song title=nil, length=nil>>
@@ -234,22 +248,22 @@ class ContractConstantTest < Minitest::Spec
   end
   #:validate-only end
 
-  it { Song::ValidateOnly.().inspect("model").must_equal %{<Result:false [#<struct ContractConstantTest::Song title=nil, length=nil>] >} }
+  it { Song::ValidateOnly.(params: {}).inspect(:model).must_equal %{<Result:false [#<struct ContractConstantTest::Song title=nil, length=nil>] >} }
   it do
-    result = Song::ValidateOnly.({ title: "Rising Forse", length: 13 })
-    result.inspect("model").must_equal %{<Result:true [#<struct ContractConstantTest::Song title=nil, length=nil>] >}
+    result = Song::ValidateOnly.(params: { title: "Rising Forse", length: 13 })
+    result.inspect(:model).must_equal %{<Result:true [#<struct ContractConstantTest::Song title=nil, length=nil>] >}
   end
 
   it do
     #:validate-only-result-false
-    result = Song::ValidateOnly.({}) # empty params
+    result = Song::ValidateOnly.(params: {}) # empty params
     result.success? #=> false
     #:validate-only-result-false end
   end
 
   it do
     #:validate-only-result
-    result = Song::ValidateOnly.({ title: "Rising Force", length: 13 })
+    result = Song::ValidateOnly.(params: { title: "Rising Force", length: 13 })
 
     result.success? #=> true
     result["model"] #=> #<struct Song title=nil, length=nil>
@@ -276,16 +290,16 @@ class DocsContractKeyTest < Minitest::Spec
   end
   #:key end
 
-  it { Song::Create.({}).inspect("model", "result.contract.default.extract").must_equal %{<Result:false [#<struct DocsContractKeyTest::Song title=nil, length=nil>, nil] >} }
-  it { Song::Create.({"song" => { title: "SVG", length: 13 }}).inspect("model").must_equal %{<Result:true [#<struct DocsContractKeyTest::Song title=\"SVG\", length=13>] >} }
+  it { Song::Create.(params: {}).inspect(:model, "result.contract.default.extract").must_equal %{<Result:false [#<struct DocsContractKeyTest::Song title=nil, length=nil>, nil] >} }
+  it { Song::Create.(params: {"song" => { title: "SVG", length: 13 }}).inspect(:model).must_equal %{<Result:true [#<struct DocsContractKeyTest::Song title=\"SVG\", length=13>] >} }
   it do
     #:key-res
-    result = Song::Create.({ "song" => { title: "Rising Force", length: 13 } })
+    result = Song::Create.(params: { "song" => { title: "Rising Force", length: 13 } })
     result.success? #=> true
     #:key-res end
 
     #:key-res-false
-    result = Song::Create.({ title: "Rising Force", length: 13 })
+    result = Song::Create.(params: { title: "Rising Force", length: 13 })
     result.success? #=> false
     #:key-res-false end
   end
@@ -308,12 +322,12 @@ class ContractNamedConstantTest < Minitest::Spec
   end
   #:constant-name end
 
-  it { Song::Create.({ title: "A" }).inspect("model").must_equal %{<Result:false [#<struct ContractNamedConstantTest::Song title=nil, length=nil>] >} }
-  it { Song::Create.({ title: "Anthony's Song", length: 13 }).inspect("model").must_equal %{<Result:true [#<struct ContractNamedConstantTest::Song title="Anthony's Song", length=13>] >} }
+  it { Song::Create.(params: { title: "A" }).inspect(:model).must_equal %{<Result:false [#<struct ContractNamedConstantTest::Song title=nil, length=nil>] >} }
+  it { Song::Create.(params: { title: "Anthony's Song", length: 13 }).inspect(:model).must_equal %{<Result:true [#<struct ContractNamedConstantTest::Song title="Anthony's Song", length=13>] >} }
 
   it do
     #:name-res
-    result = Song::Create.({ title: "A" })
+    result = Song::Create.(params: { title: "A" })
     result["contract.form"].errors.messages #=> {:title=>["is too short (minimum is 2 ch...
     #:name-res end
   end
@@ -342,13 +356,13 @@ class ContractInjectConstantTest < Minitest::Spec
   it do
   #:di-contract-call
   Create.(
-    { title: "Anthony's Song" },
+    params: { title: "Anthony's Song" },
     "contract.default.class" => MyContract
   )
   #:di-contract-call end
   end
-  it { Create.({ title: "A" }, "contract.default.class" => MyContract).inspect("model").must_equal %{<Result:false [#<struct ContractInjectConstantTest::Song id=nil, title=nil>] >} }
-  it { Create.({ title: "Anthony's Song" }, "contract.default.class" => MyContract).inspect("model").must_equal %{<Result:true [#<struct ContractInjectConstantTest::Song id=nil, title="Anthony's Song">] >} }
+  it { Create.(params: { title: "A" }, "contract.default.class" => MyContract).inspect(:model).must_equal %{<Result:false [#<struct ContractInjectConstantTest::Song id=nil, title=nil>] >} }
+  it { Create.(params: { title: "Anthony's Song" }, "contract.default.class" => MyContract).inspect(:model).must_equal %{<Result:true [#<struct ContractInjectConstantTest::Song id=nil, title="Anthony's Song">] >} }
 end
 
 class DryValidationContractTest < Minitest::Spec
@@ -360,6 +374,7 @@ class DryValidationContractTest < Minitest::Spec
   #:dry-schema
   require "dry/validation"
   class Create < Trailblazer::Operation
+    extend ClassDependencies
     extend Contract::DSL
 
     # contract to verify params formally.
@@ -384,24 +399,25 @@ class DryValidationContractTest < Minitest::Spec
   end
   #:dry-schema end
 
-  puts "@@@@@ #{Create["pipetree"].inspect(style: :rows)}"
+  puts "@@@@@ #{Trailblazer::Operation::Inspect.(Create, style: :rows)}"
 
-  it { Create.({}).inspect("model", "result.contract.params").must_equal %{<Result:false [nil, #<Dry::Validation::Result output={} errors={:id=>[\"is missing\"]}>] >} }
-  it { Create.({ id: 1 }).inspect("model", "result.contract.params").must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>, #<Dry::Validation::Result output={:id=>1} errors={}>] >} }
-  # it { Create.({ id: 1, title: "" }).inspect("model", "result.contract.form").must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>] >} }
-  it { Create.({ id: 1, title: "" }).inspect("model").must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>] >} }
-  it { Create.({ id: 1, title: "Yo" }).inspect("model").must_equal %{<Result:true [#<struct DryValidationContractTest::Song id=nil, title="Yo">] >} }
+  it { Create.(params: {}).inspect(:model, "result.contract.params").must_equal %{<Result:false [nil, #<Dry::Validation::Result output={} errors={:id=>[\"is missing\"]}>] >} }
+  it { Create.(params: { id: 1 }).inspect(:model, "result.contract.params").must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>, #<Dry::Validation::Result output={:id=>1} errors={}>] >} }
+  # it { Create.(params: { id: 1, title: "" }).inspect(:model, "result.contract.form").must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>] >} }
+  it { Create.(params: { id: 1, title: "" }).inspect(:model).must_equal %{<Result:false [#<struct DryValidationContractTest::Song id=nil, title=nil>] >} }
+  it { Create.(params: { id: 1, title: "Yo" }).inspect(:model).must_equal %{<Result:true [#<struct DryValidationContractTest::Song id=nil, title="Yo">] >} }
 
   #:dry-schema-first
   require "dry/validation"
   class Delete < Trailblazer::Operation
+    extend ClassDependencies
     extend Contract::DSL
 
     contract "params", (Dry::Validation.Schema do
       required(:id).filled
     end)
 
-    step Contract::Validate( name: "params" ), before: "operation.new"
+    step Contract::Validate( name: "params" )#, prepend: true
     #~more
     #~more end
   end
@@ -420,10 +436,11 @@ class DryExplicitSchemaTest < Minitest::Spec
   #:dry-schema-expl
   # app/concepts/comment/delete.rb
   class Delete < Trailblazer::Operation
+    extend ClassDependencies
     extend Contract::DSL
     contract "params", MySchema
 
-    step Contract::Validate( name: "params" ), before: "operation.new"
+    step Contract::Validate( name: "params" )#, prepend: true
   end
   #:dry-schema-expl end
 end
@@ -434,6 +451,7 @@ class DocContractBuilderTest < Minitest::Spec
   #- builder:
   #:builder-option
   class Create < Trailblazer::Operation
+    extend ClassDependencies
     extend Contract::DSL
 
     contract do
@@ -448,16 +466,17 @@ class DocContractBuilderTest < Minitest::Spec
     step Contract::Persist( method: :sync )
 
     def default_contract!(options, constant:, model:, **)
-      constant.new(model, current_user: self["current_user"])
+      constant.new(model, current_user: options [:current_user])
     end
   end
   #:builder-option end
 
-  it { Create.({}).inspect("model").must_equal %{<Result:false [#<struct DocContractBuilderTest::Song id=nil, title=nil>] >} }
-  it { Create.({ title: 1}, "current_user" => Module).inspect("model").must_equal %{<Result:true [#<struct DocContractBuilderTest::Song id=nil, title=1>] >} }
+  it { Create.(params: {}).inspect(:model).must_equal %{<Result:false [#<struct DocContractBuilderTest::Song id=nil, title=nil>] >} }
+  it { Create.(params: { title: 1}, :current_user => Module).inspect(:model).must_equal %{<Result:true [#<struct DocContractBuilderTest::Song id=nil, title=1>] >} }
 
   #- proc
   class Update < Trailblazer::Operation
+    extend ClassDependencies
     extend Contract::DSL
 
     contract do
@@ -468,16 +487,16 @@ class DocContractBuilderTest < Minitest::Spec
 
     step Model( Song, :new )
     #:builder-proc
-    step Contract::Build( builder: ->(options, constant:, model:, **) {
-      constant.new(model, current_user: options["current_user"])
+    step Contract::Build( builder: ->(options, constant:raise, model:raise, **) {
+      constant.new(model, current_user: options[:current_user])
     })
     #:builder-proc end
     step Contract::Validate()
     step Contract::Persist( method: :sync )
   end
 
-  it { Update.({}).inspect("model").must_equal %{<Result:false [#<struct DocContractBuilderTest::Song id=nil, title=nil>] >} }
-  it { Update.({ title: 1}, "current_user" => Module).inspect("model").must_equal %{<Result:true [#<struct DocContractBuilderTest::Song id=nil, title=1>] >} }
+  it { Update.(params: {}).inspect(:model).must_equal %{<Result:false [#<struct DocContractBuilderTest::Song id=nil, title=nil>] >} }
+  it { Update.(params: { title: 1}, :current_user => Module).inspect(:model).must_equal %{<Result:true [#<struct DocContractBuilderTest::Song id=nil, title=1>] >} }
 end
 
 class DocContractTest < Minitest::Spec
@@ -485,6 +504,7 @@ class DocContractTest < Minitest::Spec
   #---
   # with contract block, and inheritance, the old way.
   class Block < Trailblazer::Operation
+    extend ClassDependencies
     extend Contract::DSL
     contract do
       property :title
@@ -496,8 +516,8 @@ class DocContractTest < Minitest::Spec
     step Contract::Persist( method: :sync )
   end
 
-  it { Block.({}).inspect("model").must_equal %{<Result:true [#<struct DocContractTest::Song id=nil, title=nil>] >} }
-  it { Block.({ id:1, title: "Fame" }).inspect("model").must_equal %{<Result:true [#<struct DocContractTest::Song id=nil, title="Fame">] >} }
+  it { Block.(params: {}).inspect(:model).must_equal %{<Result:true [#<struct DocContractTest::Song id=nil, title=nil>] >} }
+  it { Block.(params: { id:1, title: "Fame" }).inspect(:model).must_equal %{<Result:true [#<struct DocContractTest::Song id=nil, title="Fame">] >} }
 
   class Breach < Block
     contract do
@@ -505,7 +525,7 @@ class DocContractTest < Minitest::Spec
     end
   end
 
-  it { Breach.({ id:1, title: "Fame" }).inspect("model").must_equal %{<Result:true [#<struct DocContractTest::Song id=1, title="Fame">] >} }
+  it { Breach.(params: { id:1, title: "Fame" }).inspect(:model).must_equal %{<Result:true [#<struct DocContractTest::Song id=1, title="Fame">] >} }
 
   #-
   # with constant.
@@ -517,7 +537,7 @@ class DocContractTest < Minitest::Spec
     contract MyContract
   end
 
-  it { Break.({ id:1, title: "Fame" }).inspect("model").must_equal %{<Result:true [#<struct DocContractTest::Song id=1, title=nil>] >} }
+  it { Break.(params: { id:1, title: "Fame" }).inspect(:model).must_equal %{<Result:true [#<struct DocContractTest::Song id=1, title=nil>] >} }
 end
 
 

data/test/docs/dry_test.rb

@@ -26,6 +26,6 @@ class DryContainerTest < Minitest::Spec
   end
   #:key end
 
-  it { Create.({ title: "A" }, {}, my_container).inspect("model").must_equal %{<Result:false [#<struct DryContainerTest::Song id=nil, title=nil>] >} }
-  it { Create.({ title: "Anthony's Song" }, {}, my_container).inspect("model").must_equal %{<Result:true [#<struct DryContainerTest::Song id=nil, title="Anthony's Song">] >} }
+  it { Create.({params: { title: "A" }}, my_container).inspect(:model).must_equal %{<Result:false [#<struct DryContainerTest::Song id=nil, title=nil>] >} }
+  it { Create.({params: { title: "Anthony's Song" }}, my_container).inspect(:model).must_equal %{<Result:true [#<struct DryContainerTest::Song id=nil, title="Anthony's Song">] >} }
 end

data/test/docs/fast_test.rb

@@ -24,10 +24,10 @@ class DocsFailFastOptionTest < Minitest::Spec
   end
   #:ffopt end
 
-  it { Update.(id: 1).inspect("result.model.song", "contract.default").must_equal %{<Result:false [\"Something went wrong with ID 1!\", nil] >} }
+  it { Update.(params: {id: 1}).inspect("result.model.song", "contract.default").must_equal %{<Result:false [\"Something went wrong with ID 1!\", nil] >} }
   it do
   #:ffopt-res
-    result = Update.(id: 1)
+    result = Update.(params: {id: 1})
     result["result.model.song"] #=> "Something went wrong with ID 1!"
   #:ffopt-res end
   end
@@ -50,11 +50,11 @@ class DocsFailFastOptionWithStepTest < Minitest::Spec
   end
   #:ffopt-step end
 
-  it { Update.({ id: nil }).inspect("model").must_equal %{<Result:false [nil] >} }
-  it { Update.({ id: 1 }).inspect("model").must_equal %{<Result:true [Object] >} }
+  it { Update.(params: { id: nil }).inspect(:model).must_equal %{<Result:false [nil] >} }
+  it { Update.(params: { id: 1 }).inspect(:model).must_equal %{<Result:true [Object] >} }
   it do
   #:ffopt-step-res
-    result = Update.({ id: nil })
+    result = Update.(params: { id: nil })
 
     result.failure? #=> true
     result["model"] #=> nil
@@ -85,10 +85,10 @@ class DocsPassFastWithStepOptionTest < Minitest::Spec
   end
   #:pfopt-step end
 
-  it { Update.(id: 1).inspect("result.model.song", "contract.default").must_equal %{<Result:false [\"Something went wrong with ID 1!\", nil] >} }
+  it { Update.(params: {id: 1}).inspect("result.model.song", "contract.default").must_equal %{<Result:false [\"Something went wrong with ID 1!\", nil] >} }
   it do
   #:pfopt-step-res
-    result = Update.(id: 1)
+    result = Update.(params: {id: 1})
     result["result.model.song"] #=> "Something went wrong with ID 1!"
   #:pfopt-step-res end
   end
@@ -101,7 +101,7 @@ class DocsFailFastMethodTest < Minitest::Spec
 
   #:ffmeth
   class Update < Trailblazer::Operation
-    step :filter_params!         # emits fail_fast!
+    step :filter_params!,         fast_track: true # emits fail_fast!
     step Model( Song, :find_by )
     failure :handle_fail!
 
@@ -118,10 +118,10 @@ class DocsFailFastMethodTest < Minitest::Spec
   end
   #:ffmeth end
 
-  it { Update.({}).inspect("result.params", "my.status").must_equal %{<Result:false [\"No ID in params!\", nil] >} }
+  it { Update.(params: {}).inspect("result.params", "my.status").must_equal %{<Result:false [\"No ID in params!\", nil] >} }
   it do
   #:ffmeth-res
-    result = Update.(id: 1)
+    result = Update.(params: {id: 1})
     result["result.params"] #=> "No ID in params!"
     result["my.status"]     #=> nil
   #:ffmeth-res end
@@ -139,7 +139,7 @@ class DocsPassFastMethodTest < Minitest::Spec
   #:pfmeth
   class Create < Trailblazer::Operation
     step Model( Song, :new )
-    step :empty_model!                           # emits pass_fast!
+    step :empty_model!,         fast_track: true  # emits pass_fast!
     step Contract::Build( constant: MyContract )
     # ..
 
@@ -151,14 +151,134 @@ class DocsPassFastMethodTest < Minitest::Spec
   end
   #:pfmeth end
 
-  it { Create.({ title: "Tyrant"}, "is_empty" => true).inspect("model").must_equal %{<Result:true [#<struct DocsPassFastMethodTest::Song id=nil, title=nil>] >} }
+  it { Create.(params: { title: "Tyrant"}, "is_empty" => true).inspect(:model).must_equal %{<Result:true [#<struct DocsPassFastMethodTest::Song id=nil, title=nil>] >} }
   it do
   #:pfmeth-res
-    result = Create.({}, "is_empty" => true)
+    result = Create.(params: {}, "is_empty" => true)
     result["model"] #=> #<Song id=nil, title=nil>
   #:pfmeth-res end
   end
 end
 
+
+class FastTrackWithNestedTest < Minitest::Spec
+  module Lib; end
+  module Memo; end
+
+  #:ft-nested
+  class Lib::Authenticate < Trailblazer::Operation
+    step :verify_input, fail_fast: true
+    step :user_ok?
+    #~ign
+    def verify_input(options, w:true, **); options[:w] = true; w; end
+    def user_ok?(options, u:true, **);     options[:u] = true; u; end
+    #~ign end
+  end
+  #:ft-nested end
+
+  #:ft-create
+  class Memo::Create < Trailblazer::Operation
+    step :validate
+    step Nested( Lib::Authenticate ) # fail_fast goes to End.fail_fast
+    step :create_model
+    step :save
+    #~igncr
+    def validate(options, v:true, **);     options[:v] = true; v; end
+    def create_model(options, c:true, **); options[:c] = true; c; end
+    def save(options, s:true, **);         options[:s] = true; s; end
+    #~igncr end
+  end
+  #:ft-create end
+
+  it "everything goes :success ===> End.success" do
+    result = Memo::Create.()
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:true [true, true, true, true, true] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Success
+  end
+
+  it "validate => failure ===> End.failure" do
+    result = Memo::Create.(v: false)
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, nil, nil, nil, nil] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
+  end
+
+  it "verify_input? => fail_fast ===> End.fail_fast" do
+    result = Memo::Create.(w: false)
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, nil, nil, nil] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::FailFast
+  end
+
+  it "user_ok? => fail ===> End.failure" do
+    result = Memo::Create.(u: false)
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, true, nil, nil] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
+  end
+
+  it "create_model? => fail ===> End.failure" do
+    result = Memo::Create.(c: false)
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, true, true, nil] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
+  end
+
+  module Rewire
+    module Memo; end
+
+    #:ft-rewire
+    class Memo::Create < Trailblazer::Operation
+      step :validate
+      step Nested( Lib::Authenticate ), Output(:fail_fast) => :failure
+      step :create_model
+      step :save
+      #~ignrw
+      def validate(options, v:true, **);     options[:v] = true; v; end
+      def create_model(options, c:true, **); options[:c] = true; c; end
+      def save(options, s:true, **);         options[:s] = true; s; end
+      #~ignrw end
+    end
+    #:ft-rewire end
+  end
+
+  it "everything goes :success ===> End.success" do
+    result = Rewire::Memo::Create.()
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:true [true, true, true, true, true] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Success
+  end
+
+  it "validate => failure ===> End.failure" do
+    result = Rewire::Memo::Create.(v: false)
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, nil, nil, nil, nil] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
+  end
+
+  # this is the only test differing.
+  it "verify_input? => fail_fast ===> End.failure" do
+    result = Rewire::Memo::Create.(w: false)
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, nil, nil, nil] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
+  end
+
+  it "user_ok? => fail ===> End.failure" do
+    result = Rewire::Memo::Create.(u: false)
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, true, nil, nil] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
+  end
+
+  it "create_model? => fail ===> End.failure" do
+    result = Rewire::Memo::Create.(c: false)
+
+    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, true, true, nil] >}
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
+  end
+end
+
 # fail!
 # pass!