trailblazer-macro 2.1.0.rc1 → 2.1.0.rc11

data/test/docs/guard_test.rb

@@ -110,6 +110,8 @@ end
 class DocsGuardInjectionTest < Minitest::Spec
   #:di-op
   class Create < Trailblazer::Operation
+    extend Trailblazer::Operation::Container
+
     step Policy::Guard( ->(options, current_user:, **) { current_user == Module } )
   end
   #:di-op end
@@ -118,7 +120,8 @@ class DocsGuardInjectionTest < Minitest::Spec
   it {
     result =
   #:di-call
-  Create.({},
+  Create.(
+    {},
     :current_user        => Module,
     "policy.default.eval" => Trailblazer::Operation::Policy::Guard.build(->(options, **) { false })
   )

data/test/docs/macro_test.rb

@@ -6,7 +6,7 @@ class DocsMacroTest < Minitest::Spec
     def self.MyPolicy(allowed_role: "admin")
       step = ->(input, options) { options["current_user"].type == allowed_role }
 
-      [ step, name: "my_policy.#{allowed_role}" ] # :before, :replace, etc. work, too.
+      {task: step, id: "my_policy.#{allowed_role}"} # :before, :replace, etc. work, too.
     end
   end
   #:simple end
@@ -28,7 +28,7 @@ class DocsMacroTest < Minitest::Spec
   end
 =end
 
-  it { Operation::Inspect.(Create).must_equal %{[>my_policy.manager]} }
+  it { Trailblazer::Operation::Inspect.(Create).must_equal %{[>my_policy.manager]} }
 end
 
 # injectable option

data/test/docs/nested_test.rb

@@ -1,113 +1,109 @@
 require "test_helper"
 
 class NestedInput < Minitest::Spec
-  #:input-multiply
-  class Multiplier < Trailblazer::Operation
-    step ->(options, x:, y:, **) { options["product"] = x*y }
-  end
-  #:input-multiply end
-
-  #:input-pi
-  class MultiplyByPi < Trailblazer::Operation
-    step ->(options, **) { options["pi_constant"] = 3.14159 }
-    step Nested( Multiplier, input: ->(options, **) do
-      { "y" => options["pi_constant"],
-        "x" => options["x"]
-      }
-    end )
-  end
-  #:input-pi end
+  let(:edit) do
+    edit = Class.new(Trailblazer::Operation) do
+      step :c
 
-  it { MultiplyByPi.("x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
+      include T.def_steps(:c)
+    end
+  end
 
-  it do
-    #:input-result
-    result = MultiplyByPi.("x" => 9)
-    result["product"] #=> [28.27431]
-    #:input-result end
+  let(:update) do
+    edit = Class.new(Trailblazer::Operation) do
+      step :d
+      include T.def_steps(:d)
+    end
   end
-end
 
-class NestedInputCallable < Minitest::Spec
-  Multiplier = NestedInput::Multiplier
+  it "Nested(Edit), without any options" do
+    edit = self.edit
+
+    create = Class.new(Trailblazer::Operation) do
+      step :a
+      step Nested( edit )
+      step :b
 
-  #:input-callable
-  class MyInput
-    def self.call(options, **)
-      {
-        "y" => options["pi_constant"],
-        "x" => options["x"]
-      }
+      include T.def_steps(:a, :b)
     end
-  end
-  #:input-callable end
 
-  #:input-callable-op
-  class MultiplyByPi < Trailblazer::Operation
-    step ->(options, **) { options["pi_constant"] = 3.14159 }
-    step Nested( Multiplier, input: MyInput )
+    # this will print a DEPRECATION warning.
+  # success
+    create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
+  # failure in Nested
+    create.(seq: [], c: false).inspect(:seq).must_equal %{<Result:false [[:a, :c]] >}
   end
-  #:input-callable-op end
-
-  it { MultiplyByPi.("x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
-end
 
-class NestedWithCallableAndInputTest < Minitest::Spec
-  Memo = Struct.new(:title, :text, :created_by)
+  it "Nested(Edit), with Output rewiring" do
+    edit = self.edit
 
-  class Memo::Upsert < Trailblazer::Operation
-    step Nested( :operation_class, input: :input_for_create )
+    create = Class.new(Trailblazer::Operation) do
+      step :a
+      step Nested( edit ), Output(:failure) => Track(:success)
+      step :b
 
-    def operation_class( ctx, ** )
-      ctx[:id] ? Update : Create
+      include T.def_steps(:a, :b)
     end
 
-    # only let :title pass through.
-    def input_for_create( ctx, ** )
-      { title: ctx[:title] }
-    end
+  # success
+    create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
+  # failure in Nested
+    create.(seq: [], c: false).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
+  end
 
-    class Create < Trailblazer::Operation
-      step :create_memo
+  it "Nested(:method)" do
+    create = Class.new(Trailblazer::Operation) do
+      step :a
+      step Nested(:compute_edit)
+      step :b
 
-      def create_memo( ctx, ** )
-        ctx[:model] = Memo.new(ctx[:title], ctx[:text], :create)
+      def compute_edit(ctx, what:, **)
+        what
       end
+
+      include T.def_steps(:a, :b)
     end
 
-    class Update < Trailblazer::Operation
-      step :find_by_title
+    # `edit` and `update` can be called from Nested()
 
-      def find_by_title( ctx, ** )
-        ctx[:model] = Memo.new(ctx[:title], ctx[:text], :update)
-      end
-    end
-  end
+  # edit/success
+    create.(seq: [], what: edit).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
 
-  it "runs Create without :id" do
-    Memo::Upsert.( title: "Yay!" ).inspect(:model).
-      must_equal %{<Result:true [#<struct NestedWithCallableAndInputTest::Memo title=\"Yay!\", text=nil, created_by=:create>] >}
-  end
+  # update/success
+    create.(seq: [], what: update).inspect(:seq).must_equal %{<Result:true [[:a, :d, :b]] >}
 
-  it "runs Update without :id" do
-    Memo::Upsert.( id: 1, title: "Yay!" ).inspect(:model).
-      must_equal %{<Result:true [#<struct NestedWithCallableAndInputTest::Memo title=\"Yay!\", text=nil, created_by=:update>] >}
+
+# wiring of fail:
+  # edit/failure
+    create.(seq: [], what: edit, c: false).inspect(:seq).must_equal %{<Result:false [[:a, :c]] >}
+  # update/failure
+    create.(seq: [], what: update, d: false).inspect(:seq).must_equal %{<Result:false [[:a, :d]] >}
   end
-end
 
-# builder: Nested + deviate to left if nil / skip_track if true
+  let(:compute_edit) {
+    ->(ctx, what:, **) { what }
+  }
+
+  it "Nested(:method), :pass_fast => :fail_fast doesn't work with standard wiring" do
+    skip "we need to allow adding :outputs"
 
-#---
-# automatic :name
-class NestedNameTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    class Present < Trailblazer::Operation
-      # ...
+    compute_edit = self.compute_edit
+
+    pass_fast = Class.new(Trailblazer::Operation) do
+      step :p, pass_fast: true
+      include T.def_steps(:p)
     end
 
-    step Nested( Present )
-    # ...
-  end
+    create = Class.new(Trailblazer::Operation) do
+      step :a
+      step Nested(compute_edit, auto_wire: [pass_fast]), Output(:pass_fast) => Track(:fail_fast)
+      step :b
+      include T.def_steps(:a, :b)
+    end
 
-  it { Operation::Inspect.(Create).must_equal %{[>Nested(NestedNameTest::Create::Present)]} }
+
+    create.(seq: [], what: pass_fast).inspect(:seq).must_equal %{<Result:false [[:a, :c]] >}
+  end
 end
+
+# TODO: test with :input/:output, tracing

data/test/docs/rescue_test.rb

@@ -11,16 +11,16 @@ class NestedRescueTest < Minitest::Spec
       step ->(options, **) { options["a"] = true }
       step Rescue {
         step ->(options, **) { options["y"] = true }
-        success ->(options, **) { raise Y if options["raise-y"] }
+        pass ->(options, **) { raise Y if options["raise-y"] }
         step ->(options, **) { options["z"] = true }
       }
       step ->(options, **) { options["b"] = true }
-      success ->(options, **) { raise A if options["raise-a"] }
+      pass ->(options, **) { raise A if options["raise-a"] }
       step ->(options, **) { options["c"] = true }
-      failure ->(options, **) { options["inner-err"] = true }
+      fail ->(options, **) { options["inner-err"] = true }
     }
     step ->(options, **) { options["e"] = true }, id: "nested/e"
-    failure ->(options, **) { options["outer-err"] = true }, id: "nested/failure"
+    fail ->(options, **) { options["outer-err"] = true }, id: "nested/failure"
   end
 
   it { Trailblazer::Operation::Inspect.(NestedInsanity).must_match /\[>Rescue\(\d+\),>nested/ } # FIXME: better introspect tests for all id-generating macros.
@@ -54,7 +54,8 @@ plain Rescue()
       step :notify
       fail :log_error
       #~methods
-      include Test::Methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
       #~methods end
     end
 
@@ -86,7 +87,8 @@ Rescue( handler: X )
       step :notify
       fail :log_error
       #~methods
-      include Test::Methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
       #~methods end
     end
     #:rescue end
@@ -111,7 +113,8 @@ Rescue( handler: :instance_method )
       step :notify
       fail :log_error
       #~methods
-      include Test::Methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
       #~methods end
 
       def my_handler(exception, (ctx), *)

data/test/docs/wrap_test.rb

@@ -30,7 +30,8 @@ When raise:   return {Railway.fail!}
     step :notify
     fail :log_error
     #~methods
-    include Test::Methods
+    include T.def_steps(:find_model, :update, :notify, :log_error)
+    include Rehash
     #~methods end
   end
   #:wrap end
@@ -76,6 +77,8 @@ When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
           begin
             yield # calls the wrapped steps
           rescue
+            puts $!
+            ctx[:exception] = $!.message
             [ Trailblazer::Operation::Railway.fail!, [ctx, {}] ]
           end
         end
@@ -90,7 +93,8 @@ When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
       fail :log_error
 
       #~methods
-      include Test::Methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
       #~methods end
     end
 
@@ -127,7 +131,8 @@ When raise:   return {Railway.fail_fast!} and configure Wrap() to {fast_track: t
       step :notify
       fail :log_error
       #~methods
-      include Test::Methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
       #~methods end
     end
     #:fail-fast end
@@ -176,7 +181,8 @@ When raise:   return {Railway.fail!} or {Railway.pass!}
       step :notify
       fail :log_error
       #~methods
-      include Test::Methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
       #~methods end
     end
     #:transaction end
@@ -219,7 +225,8 @@ When raise:   return {Railway.fail!} or {Railway.pass!}
       step :notify
       fail :log_error
       #~methods
-      include Test::Methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
       #~methods end
     end
     #:custom end
@@ -264,7 +271,8 @@ When raise:   return {Railway.pass!} and go "successful"
       fail :log_error
 
       #~methods
-      include Test::Methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
       #~methods end
     end
 

data/test/operation/integration_test.rb

@@ -0,0 +1,55 @@
+require "test_helper"
+
+class IntegrationTest < Minitest::Spec
+  Artist = Struct.new(:name)
+  Song = Struct.new(:name, :artist_name)
+
+  class SongCreate < Trailblazer::Operation
+    step Model(Song, :new)
+    # step ->(options, **) { options[:model] = Song.new }
+    step :set_artist!
+    step :save!
+
+    def set_artist!(_options, model:, params:, **)
+      model.artist_name = params[:artist][:name]
+    end
+
+    def save!(_options, params:, model:, **)
+      model.name = params[:song][:name]
+    end
+  end
+
+  class ArtistCreate < Trailblazer::Operation
+    # step ->(options, **) { options[:model] = Artist.new }
+    step Model(Artist, :new)
+    step :save!
+
+    def save!(_options, params:, model:, **)
+      model.name = params[:artist][:name]
+    end
+  end
+
+  class SongSpecialCreate < Trailblazer::Operation
+    step Nested(ArtistCreate)
+    step Nested(SongCreate)
+  end
+
+  it "create Artist and Song" do
+    result = SongSpecialCreate.trace(
+      params: {
+        artist: {
+          name: "My Artist"
+        },
+        song: {
+          name: "My Song"
+        }
+      }
+    )
+
+    puts result.wtf?
+
+    # this should return song
+    result[:model].name.must_match "My Song"
+    result[:model].artist_name.must_match "My Artist"
+  end
+end

data/test/operation/model_test.rb

@@ -13,15 +13,23 @@ class ModelTest < Minitest::Spec
 
   #---
   # use Model semantics, no customizations.
+  # class Create < Trailblazer::Operation
   class Create < Trailblazer::Operation
-    step Model( Song, :new )
+    step Trailblazer::Operation::Model( Song, :new )
   end
 
   # :new new.
   it { Create.(params: {})[:model].inspect.must_equal %{#<struct ModelTest::Song id=nil, title=nil>} }
+  it do
+
+    result = Create.(params: {})
+
+    result[:model].inspect.must_equal %{#<struct ModelTest::Song id=nil, title=nil>}
+  end
 
-  class Update < Create
-    step Model( Song, :find ), override: true
+  # class Update < Create
+  class Update < Trailblazer::Operation
+    step Trailblazer::Operation::Model( Song, :find )#, override: true
   end
 
   #---
@@ -35,16 +43,18 @@ class ModelTest < Minitest::Spec
 
   #---
   # :find_by, exceptionless.
+  # class Find < Trailblazer::Operation
   class Find < Trailblazer::Operation
-    step Model Song, :find_by
+    step Trailblazer::Operation::Model Song, :find_by
     step :process
 
     def process(options, **); options["x"] = true end
   end
 
   # :find_by, exceptionless.
+  # class FindByKey < Trailblazer::Operation
   class FindByKey < Trailblazer::Operation
-    step Model( Song, :find_by, :title )
+    step Trailblazer::Operation::Model( Song, :find_by, :title )
     step :process
 
     def process(options, **); options["x"] = true end