trailblazer-macro 2.1.0.beta1

data/test/docs/pundit_test.rb

@@ -0,0 +1,133 @@
+require "test_helper"
+
+  #:policy
+  class MyPolicy
+    def initialize(user, model)
+      @user, @model = user, model
+    end
+
+    def create?
+      @user == Module && @model.id.nil?
+    end
+
+    def new?
+      @user == Class
+    end
+  end
+  #:policy end
+
+#--
+# with policy
+class DocsPunditProcTest < Minitest::Spec
+  Song = Struct.new(:id)
+
+  #:pundit
+  class Create < Trailblazer::Operation
+    step Model( Song, :new )
+    step Policy::Pundit( MyPolicy, :create? )
+    # ...
+  end
+  #:pundit end
+
+  it { Trailblazer::Operation::Inspect.(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 do
+  #:pundit-result
+  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
+  end
+
+  #---
+  #- override
+  class New < Create
+    step Policy::Pundit( MyPolicy, :new? ), override: true
+  end
+
+  it { Trailblazer::Operation::Inspect.(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>] >} }
+
+  #---
+  #- override with :name
+  class Edit < Trailblazer::Operation
+    step Policy::Pundit( MyPolicy, :create?, name: "first" )
+    step Policy::Pundit( MyPolicy, :new?,    name: "second" )
+  end
+
+  class Update < Edit
+    step Policy::Pundit( MyPolicy, :new?, name: "first" ), override: true
+  end
+
+  it { Trailblazer::Operation::Inspect.(Edit).must_equal %{[>policy.first.eval,>policy.second.eval]} }
+  it { Edit.(params: {}, current_user: Class).inspect(:model).must_equal %{<Result:false [nil] >} }
+  it { Trailblazer::Operation::Inspect.(Update).must_equal %{[>policy.first.eval,>policy.second.eval]} }
+  it { Update.(params: {}, current_user: Class).inspect(:model).must_equal %{<Result:true [nil] >} }
+
+  #---
+  # dependency injection
+  class AnotherPolicy < MyPolicy
+    def create?
+      true
+    end
+  end
+
+  it {
+    result =
+  #:di-call
+  Create.(params: {},
+    current_user:            Module,
+    "policy.default.eval" => Trailblazer::Operation::Policy::Pundit.build(AnotherPolicy, :create?)
+  )
+  #:di-call end
+    result.inspect("").must_equal %{<Result:true [nil] >} }
+end
+
+#-
+# with name:
+class PunditWithNameTest < Minitest::Spec
+  Song = Struct.new(:id)
+
+  #:name
+  class Create < Trailblazer::Operation
+    step Model( Song, :new )
+    step Policy::Pundit( MyPolicy, :create?, name: "after_model" )
+    # ...
+  end
+  #:name end
+
+  it {
+  #:name-call
+  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 }
+end
+
+#---
+# class-level guard
+# class DocsGuardClassLevelTest < Minitest::Spec
+#   #:class-level
+#   class Create < Trailblazer::Operation
+#     step Policy::Guard[ ->(options) { options["current_user"] == Module } ],
+#       before: "operation.new"
+#     #~pipe--only
+#     step ->(options) { options["x"] = true }
+#     #~pipe--only end
+#   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: {}                          )["x"].must_be_nil }
+# end
+
+
+
+# TODO:
+#policy.default

data/test/docs/rescue_test.rb

@@ -0,0 +1,126 @@
+require "test_helper"
+
+class NestedRescueTest < Minitest::Spec
+  #---
+  # nested raise (i hope people won't use this but it works)
+  A = Class.new(RuntimeError)
+  Y = Class.new(RuntimeError)
+
+  class NestedInsanity < Trailblazer::Operation
+    step Rescue {
+      step ->(options, **) { options["a"] = true }
+      step Rescue {
+        step ->(options, **) { options["y"] = true }
+        success ->(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"] }
+      step ->(options, **) { options["c"] = true }
+      failure ->(options, **) { options["inner-err"] = true }
+    }
+    step ->(options, **) { options["e"] = true }, id: "nested/e"
+    failure ->(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.
+  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] >} }
+
+  #-
+  # 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] >} }
+end
+
+class RescueTest < Minitest::Spec
+
+=begin
+plain Rescue()
+=end
+  class RescueWithoutHandlerTest < Minitest::Spec
+    Memo = Class.new
+
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Rescue() {
+        step :update
+        step :rehash
+      }
+      step :notify
+      fail :log_error
+      #~methods
+      include Test::Methods
+      #~methods end
+    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]] >} }
+  end
+
+=begin
+Rescue( handler: X )
+=end
+  class RescueWithHandlerTest < Minitest::Spec
+    Memo = Class.new
+
+    #:rescue-handler
+    class MyHandler
+      def self.call(exception, (ctx), *)
+        ctx[:exception_class] = exception.class
+      end
+    end
+    #:rescue-handler end
+
+    #:rescue
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Rescue( RuntimeError, handler: MyHandler ) {
+        step :update
+        step :rehash
+      }
+      step :notify
+      fail :log_error
+      #~methods
+      include Test::Methods
+      #~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] >} }
+  end
+
+=begin
+Rescue( handler: :instance_method )
+=end
+  class RescueWithHandlerTest < Minitest::Spec
+    Memo = Class.new
+
+    #:rescue-method
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Rescue( RuntimeError, handler: :my_handler ) {
+        step :update
+        step :rehash
+      }
+      step :notify
+      fail :log_error
+      #~methods
+      include Test::Methods
+      #~methods end
+
+      def my_handler(exception, (ctx), *)
+        ctx[:exception_class] = exception.class
+      end
+    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] >} }
+  end
+end

data/test/docs/wrap_test.rb

@@ -0,0 +1,274 @@
+require "test_helper"
+
+class DocsWrapTest < Minitest::Spec
+  module Memo
+  end
+
+=begin
+When success: return the block's returns
+When raise:   return {Railway.fail!}
+=end
+  #:wrap-handler
+  class HandleUnsafeProcess
+    def self.call((ctx, flow_options), *, &block)
+      begin
+        yield # calls the wrapped steps
+      rescue
+        [ Trailblazer::Operation::Railway.fail!, [ctx, flow_options] ]
+      end
+    end
+  end
+  #:wrap-handler end
+
+  #:wrap
+  class Memo::Create < Trailblazer::Operation
+    step :find_model
+    step Wrap( HandleUnsafeProcess ) {
+      step :update
+      step :rehash
+    }
+    step :notify
+    fail :log_error
+    #~methods
+    include Test::Methods
+    #~methods end
+  end
+  #:wrap end
+
+  it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
+  it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error]] >} }
+
+=begin
+Tracing with Wrap()
+=end
+  it do
+    options = { seq: [] }
+    #:trace-call
+    result  = Memo::Create.trace( options )
+    #:trace-call end
+    result.wtf.gsub("\n", "").must_match /.*Start.*find_model.*Wrap.*update.*rehash.*success.*notify.*success/
+=begin
+#:trace-success
+result.wtf? #=>
+|-- #<Trailblazer::Activity::Start semantic=:default>
+|-- find_model
+|-- Wrap/85
+|   |-- #<Trailblazer::Activity::Start semantic=:default>
+|   |-- update
+|   |-- rehash
+|   `-- #<Trailblazer::Operation::Railway::End::Success semantic=:success>
+|-- notify
+`-- #<Trailblazer::Operation::Railway::End::Success semantic=:success>
+#:trace-success end
+=end
+  end
+
+=begin
+When success: return the block's returns
+When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
+=end
+  class WrapGoesIntoFailFastTest < Minitest::Spec
+    Memo = Module.new
+
+    class Memo::Create < Trailblazer::Operation
+      class HandleUnsafeProcess
+        def self.call((ctx), *, &block)
+          begin
+            yield # calls the wrapped steps
+          rescue
+            [ Trailblazer::Operation::Railway.fail!, [ctx, {}] ]
+          end
+        end
+      end
+
+      step :find_model
+      step Wrap( HandleUnsafeProcess ) {
+        step :update
+        step :rehash
+      }, fail_fast: true
+      step :notify
+      fail :log_error
+
+      #~methods
+      include Test::Methods
+      #~methods end
+    end
+
+    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:find_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}
+=end
+  class WrapGoesIntoFailFastViaFastTrackTest < Minitest::Spec
+    Memo = Module.new
+
+    #:fail-fast-handler
+    class HandleUnsafeProcess
+      def self.call((ctx), *, &block)
+        begin
+          yield # calls the wrapped steps
+        rescue
+          [ Trailblazer::Operation::Railway.fail_fast!, [ctx, {}] ]
+        end
+      end
+    end
+    #:fail-fast-handler end
+
+    #:fail-fast
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Wrap( HandleUnsafeProcess ) {
+        step :update
+        step :rehash
+      }, fast_track: true
+      step :notify
+      fail :log_error
+      #~methods
+      include Test::Methods
+      #~methods end
+    end
+    #:fail-fast end
+
+    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash]] >} }
+  end
+
+=begin
+When success: return the block's returns
+When raise:   return {Railway.fail!} or {Railway.pass!}
+=end
+  class WrapWithTransactionTest < Minitest::Spec
+    Memo = Module.new
+
+    module Sequel
+      def self.transaction
+        begin
+          end_event, (ctx, flow_options) = yield
+          true
+        rescue
+          false
+        end
+      end
+    end
+
+    #:transaction-handler
+    class MyTransaction
+      def self.call((ctx, flow_options), *, &block)
+        result = Sequel.transaction { yield }
+
+        signal = result ? Trailblazer::Operation::Railway.pass! : Trailblazer::Operation::Railway.fail!
+
+        [ signal, [ctx, flow_options] ]
+      end
+    end
+    #:transaction-handler end
+
+    #:transaction
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Wrap( MyTransaction ) {
+        step :update
+        step :rehash
+      }
+      step :notify
+      fail :log_error
+      #~methods
+      include Test::Methods
+      #~methods end
+    end
+    #:transaction end
+
+    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error]] >} }
+  end
+
+=begin
+When success: return the block's returns
+When raise:   return {Railway.fail!} or {Railway.pass!}
+=end
+  class WrapWithCustomEndsTest < Minitest::Spec
+    Memo   = Module.new
+    Sequel = WrapWithTransactionTest::Sequel
+
+    #:custom-handler
+    class MyTransaction
+      MyFailSignal = Class.new(Trailblazer::Activity::Signal)
+
+      def self.call((ctx, flow_options), *, &block)
+        result = Sequel.transaction { yield }
+
+        signal = result ? Trailblazer::Operation::Railway.pass! : MyFailSignal
+
+        [ signal, [ctx, flow_options] ]
+      end
+    end
+    #:custom-handler end
+
+    #:custom
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Wrap( MyTransaction ) {
+        step :update
+        step :rehash
+      },
+        Output(:success) => End(:transaction_worked),
+        Output(MyTransaction::MyFailSignal, :failure) => End(:transaction_failed)
+      step :notify
+      fail :log_error
+      #~methods
+      include Test::Methods
+      #~methods end
+    end
+    #:custom end
+
+    it do
+      result = Memo::Create.( { seq: [] } )
+      result.inspect(:seq).must_equal %{<Result:false [[:find_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.inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_failed>}
+    end
+  end
+
+=begin
+When success: return the block's returns
+When raise:   return {Railway.pass!} and go "successful"
+=end
+  class WrapGoesIntoPassFromRescueTest < Minitest::Spec
+    Memo = Module.new
+
+    class Memo::Create < Trailblazer::Operation
+      class HandleUnsafeProcess
+        def self.call((ctx), *, &block)
+          begin
+            yield # calls the wrapped steps
+          rescue
+            [ Trailblazer::Operation::Railway.pass!, [ctx, {}] ]
+          end
+        end
+      end
+
+      step :find_model
+      step Wrap( HandleUnsafeProcess ) {
+        step :update
+        step :rehash
+      }
+      step :notify
+      fail :log_error
+
+      #~methods
+      include Test::Methods
+      #~methods end
+    end
+
+    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
+  end
+end