trailblazer-macro 2.1.0.beta1

data/test/lib/methods.rb

@@ -0,0 +1,25 @@
+module Test
+  module Methods
+    def find_model(ctx, seq:, **)
+      seq << :find_model
+    end
+
+    def update(ctx, seq:, **)
+      seq << :update
+    end
+
+    def notify(ctx, seq:, **)
+      seq << :notify
+    end
+
+    def rehash(ctx, seq:, rehash_raise:false, **)
+      seq << :rehash
+      raise if rehash_raise
+      true
+    end
+
+    def log_error(ctx, seq:, **)
+      seq << :log_error
+    end
+  end
+end

data/test/operation/model_test.rb

@@ -0,0 +1,54 @@
+require "test_helper"
+
+class ModelTest < Minitest::Spec
+  Song = Struct.new(:id) do
+    def self.find(id); new(id) end
+    def self.find_by(id:nil); id.nil? ? nil : new(id) end
+  end
+
+  #---
+  # use Model semantics, no customizations.
+  class Create < Trailblazer::Operation
+    step Model( Song, :new )
+  end
+
+  # :new new.
+  it { Create.(params: {})[:model].inspect.must_equal %{#<struct ModelTest::Song id=nil>} }
+
+  class Update < Create
+    step Model( Song, :find ), override: true
+  end
+
+  #---
+  #- inheritance
+
+  # :find it
+  it { Update.(params: { id: 1 })[:model].inspect.must_equal %{#<struct ModelTest::Song id=1>} }
+
+  # inherited inspect is ok
+  it { Trailblazer::Operation::Inspect.(Update).must_equal %{[>model.build]} }
+
+  #---
+  # :find_by, exceptionless.
+  class Find < Trailblazer::Operation
+    step Model Song, :find_by
+    step :process
+
+    def process(options, **); options["x"] = true end
+  end
+
+  # can't find model.
+  #- result object, model
+  it do
+    Find.(params: {id: nil})["result.model"].failure?.must_equal true
+    Find.(params: {id: nil})["x"].must_be_nil
+    Find.(params: {id: nil}).failure?.must_equal true
+  end
+
+  #- result object, model
+  it do
+    Find.(params: {id: 9})["result.model"].success?.must_equal true
+    Find.(params: {id: 9})["x"].must_equal true
+    Find.(params: {id: 9})[:model].inspect.must_equal %{#<struct ModelTest::Song id=9>}
+  end
+end

data/test/operation/nested_test.rb

@@ -0,0 +1,293 @@
+require "test_helper"
+
+# exec_context nach Nested
+
+class NestedTest < Minitest::Spec
+  #---
+  #- shared data
+  class B < Trailblazer::Operation
+    pass ->(options, **) { options["can.B.see.A.mutable.data?"] = options["mutable.data.from.A"] }
+    pass ->(options, **) { options["can.B.see.current_user?"]   = options["current_user"] }
+    pass ->(options, **) { options["can.B.see.params?"]         = options["params"] }
+    pass ->(options, **) { options["can.B.see.A.class.data?"]   = options["A.class.data"] }
+    pass ->(options, **) { options["can.B.see.container.data?"] = options["some.container.data"] }
+    pass ->(options, **) { options["mutable.data.from.B"]       = "from B!" }
+  end
+
+  class A < Trailblazer::Operation
+    extend ClassDependencies
+    self["A.class.data"] = "yes"                                   # class data on A
+
+    pass ->(options, **) { options["mutable.data.from.A"] = "from A!" } # mutable data on A
+    step Nested( B )
+    pass ->(options, **) { options["can.A.see.B.mutable.data?"] = options["mutable.data.from.B"] }
+  end
+
+  #---
+  #- default behavior: share everything.
+  # no containers
+  # no runtime data
+  # no params
+  it do
+    result = A.("params" => {})
+    # everything from A visible
+    result["A.class.data"].       must_equal "yes"
+    result["mutable.data.from.A"].must_equal "from A!"
+
+    # B can see everything
+    result["can.B.see.A.mutable.data?"].must_equal "from A!"
+    result["can.B.see.current_user?"].must_be_nil
+    result["can.B.see.params?"].must_equal({})
+    result["can.B.see.A.class.data?"].must_equal "yes"
+    result["can.B.see.container.data?"].must_be_nil
+
+    result["can.A.see.B.mutable.data?"].must_equal "from B!"
+  end
+
+  #---
+  #- Nested::NonActivity
+  class AlmostB < Trailblazer::Operation
+    step ->(options, is_successful:raise, **) { is_successful } # {AlmostB} fails if {is_successful} isn't true.
+    step ->(options, **) { options["can.B.see.A.mutable.data?"] = options["mutable.data.from.A"] }
+    pass ->(options, **) { options["mutable.data.from.B"]       = "from AlmostB!" }
+  end
+
+  #- Nested( ->{} )
+  class SomeNestedWithProc < Trailblazer::Operation
+    extend ClassDependencies
+    self["A.class.data"] = "yes"                                   # class data on A
+
+    Decider = ->(options, use_class:raise, **) { use_class }
+
+    pass ->(options, **) { options["mutable.data.from.A"] = "from A!" } # mutable data on A
+    step Nested( Decider )
+    pass ->(options, **) { options["can.A.see.B.mutable.data?"] = options["mutable.data.from.B"] }
+  end
+
+  #- Nested( Callable )
+  class SomeNestedWithCallable < Trailblazer::Operation
+    extend ClassDependencies
+    self["A.class.data"] = "yes"                                   # class data on A
+
+    class Decider
+      def self.call(options, use_class:raise, **)
+        use_class
+      end
+    end
+
+    pass ->(options, **) { options["mutable.data.from.A"] = "from A!" } # mutable data on A
+    step Nested( Decider )
+    pass ->(options, **) { options["can.A.see.B.mutable.data?"] = options["mutable.data.from.B"] }
+  end
+
+  #- Nested( :method )
+  class SomeNestedWithMethod < Trailblazer::Operation
+    extend ClassDependencies
+    self["A.class.data"] = "yes"                                   # class data on A
+
+    def decider(options, use_class:raise, **)
+      use_class
+    end
+
+    pass ->(options, **) { options["mutable.data.from.A"] = "from A!" } # mutable data on A
+    step Nested( :decider )
+    pass ->(options, **) { options["can.A.see.B.mutable.data?"] = options["mutable.data.from.B"] }
+  end
+
+
+  #- test callable
+  # B with Callable, successful
+  it do
+    result = SomeNestedWithCallable.("params" => {}, use_class: B)
+    assert_b(result, is_successful: "whatever")
+  end
+
+  # AlmostB with Callable, successful
+  it do
+    result = SomeNestedWithCallable.("params" => {}, use_class: AlmostB, is_successful: true)
+    assert_almost_b(result, is_successful: true)
+  end
+
+  # AlmostB with Callable, failure
+  it do
+    result = SomeNestedWithCallable.("params" => {}, use_class: AlmostB, is_successful: false)
+    assert_almost_b(result, is_successful: false)
+  end
+
+  #- test proc
+  # B with proc, successful
+  it do
+    result = SomeNestedWithProc.("params" => {}, use_class: B)
+    assert_b(result, is_successful: "whatever")
+  end
+
+  # AlmostB with proc, successful
+  it do
+    result = SomeNestedWithProc.("params" => {}, use_class: AlmostB, is_successful: true)
+
+    assert_almost_b(result, is_successful: true)
+  end
+
+  # AlmostB with proc, failure.
+  it do
+    result = SomeNestedWithProc.("params" => {}, use_class: AlmostB, is_successful: false)
+
+    assert_almost_b(result, is_successful: false)
+  end
+
+  #- test :method
+  # B with method, successful
+  it do
+    result = SomeNestedWithMethod.("params" => {}, use_class: B)
+    assert_b(result, is_successful: "whatever")
+  end
+
+  # AlmostB with method, successful
+  it do
+    result = SomeNestedWithMethod.("params" => {}, use_class: AlmostB, is_successful: true)
+
+    assert_almost_b(result, is_successful: true)
+  end
+
+  # AlmostB with method, failure.
+  it do
+    result = SomeNestedWithMethod.("params" => {}, use_class: AlmostB, is_successful: false)
+
+    assert_almost_b(result, is_successful: false)
+  end
+
+
+  def assert_almost_b(result, is_successful:raise)
+    result.success?.must_equal is_successful # AlmostB was successful, so A is successful.
+
+    # everything from A visible
+    result["A.class.data"].       must_equal "yes"
+    result["mutable.data.from.A"].must_equal "from A!"
+
+    # AlmostB doesn't look for everything
+    result["can.B.see.current_user?"].must_be_nil
+    result["can.B.see.params?"].must_be_nil
+    if is_successful
+      result["can.B.see.A.mutable.data?"].must_equal "from A!"
+      result["can.B.see.A.class.data?"].must_be_nil # we don't look for it.
+      result["can.A.see.B.mutable.data?"].must_equal "from AlmostB!"
+    else
+      result["can.B.see.A.mutable.data?"].must_be_nil
+      result["can.B.see.A.class.data?"].must_be_nil
+      result["can.A.see.B.mutable.data?"].must_be_nil
+    end
+    result["can.B.see.container.data?"].must_be_nil
+
+
+    # result[:is_successful].must_equal is_successful # FIXME: this is wrong!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! key is symbol
+  end
+
+  def assert_b(result, is_successful:raise)
+    # everything from A visible
+    result["A.class.data"].       must_equal "yes"
+    result["mutable.data.from.A"].must_equal "from A!"
+
+    # B can see everything
+    result["can.B.see.A.mutable.data?"].must_equal "from A!"
+    result["can.B.see.current_user?"].must_be_nil
+    result["can.B.see.params?"].must_equal({})
+    result["can.B.see.A.class.data?"].must_equal "yes"
+    result["can.B.see.container.data?"].must_be_nil
+
+    result["can.A.see.B.mutable.data?"].must_equal "from B!"
+
+    result[:is_successful].must_be_nil
+    result.success?.must_equal true # B was successful, so A is successful.
+  end
+
+
+  #---
+  #- :exec_context
+  class Create < Trailblazer::Operation
+    class Edit < Trailblazer::Operation
+      step :c!
+
+      def c!(options, **); options[:c] = 1 end
+    end
+
+    step :a!
+    step Nested( Edit )
+    step :b!
+
+    def a!(options, **); options[:a] = 2 end
+    def b!(options, **); options[:b] = 3 end
+  end
+
+  it { Create.().inspect(:a, :b, :c).must_equal %{<Result:true [2, 3, 1] >} }
+end
+
+class NestedWithFastTrackTest < Minitest::Spec
+  module Steps
+    def b(options, a:, **)
+      options["b"] = a+1
+    end
+
+    def f(options, **)
+      options["f"] = 3
+    end
+  end
+
+  class Edit < Trailblazer::Operation
+    pass :a, pass_fast: true
+
+    def a(options, **)
+      options["a"] = 1
+    end
+  end
+
+  class Update < Trailblazer::Operation
+    step Nested( Edit )
+    step :b
+    fail :f
+
+    include Steps
+  end
+
+  # from Nested straight to End.pass_fast.
+  it { Update.({}).inspect("a", "b", "f").must_equal %{<Result:true [1, nil, nil] >} }
+
+  #- Nested, pass_fast: true
+  class Upsert < Trailblazer::Operation
+    step Nested( Edit ), pass_fast: true # this option is unnecessary.
+    step :b
+    fail :f
+
+    include Steps
+  end
+
+  # from Nested straight to End.pass_fast.
+  it { Upsert.({}).inspect("a", "b", "f").must_equal %{<Result:true [1, nil, nil] >} }
+
+  #- mapping
+  #- Nested, :pass_fast => :failure
+  it "attaches :pass_fast => :failure" do
+    op = Class.new(Trailblazer::Operation) do
+      step Nested( Edit ), Output(:pass_fast) => Track(:failure)
+      step :b
+      fail :f
+
+      include Steps
+    end
+
+    # from Nested to :failure track.
+    op.({}).inspect("a", "b", "c", "f").must_equal %{<Result:false [1, nil, nil, 3] >}
+  end
+
+  it "goes straigt to End.failure" do
+    op = Class.new(Trailblazer::Operation) do
+      step Nested( Edit ), Output(:pass_fast) => "End.failure"
+      step :b
+      fail :f
+
+      include Steps
+    end
+
+    # from Nested straight to End.failure, no fail step will be visited.
+    op.({}).inspect("a", "b", "c", "f").must_equal %{<Result:false [1, nil, nil, nil] >}
+  end
+end

data/test/operation/pundit_test.rb

@@ -0,0 +1,106 @@
+require "test_helper"
+require "trailblazer/operation/policy"
+
+class PolicyTest < Minitest::Spec
+  Song = Struct.new(:id) do
+    def self.find(id); new(id) end
+  end
+
+  class Auth
+    def initialize(user, model); @user, @model = user, model end
+    def only_user?; @user == Module && @model.nil? end
+    def user_object?; @user == Object end
+    def user_and_model?; @user == Module && @model.class == Song end
+    def inspect; "<Auth: user:#{@user.inspect}, model:#{@model.inspect}>" end
+  end
+
+  #---
+  # Instance-level: Only policy, no model
+  class Create < Trailblazer::Operation
+    step Policy::Pundit( Auth, :only_user? )
+    step :process
+
+    def process(options, **)
+      options["process"] = true
+    end
+  end
+
+  # successful.
+  it do
+    result = Create.(params: {}, current_user: Module)
+    result["process"].must_equal true
+    #- result object, policy
+    result["result.policy.default"].success?.must_equal true
+    result["result.policy.default"]["message"].must_be_nil
+    # result[:valid].must_be_nil
+    result["policy.default"].inspect.must_equal %{<Auth: user:Module, model:nil>}
+  end
+  # breach.
+  it do
+    result = Create.(params: {}, current_user: nil)
+    result["process"].must_be_nil
+    #- result object, policy
+    result["result.policy.default"].success?.must_equal false
+    result["result.policy.default"]["message"].must_equal "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 }
+
+
+  #---
+  # inheritance, adding Model
+  class Show < Create
+    step Model( Song, :new ), before: "policy.default.eval"
+  end
+
+  it { Trailblazer::Operation::Inspect.(Show).must_equal %{[>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>}
+  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>>}
+  end
+
+  ##--
+  # TOOOODOOO: Policy and Model before Build ("External" or almost Resolver)
+  class Edit < Trailblazer::Operation
+    step Model Song, :find
+    step Policy::Pundit( Auth, :user_and_model? )
+    step :process
+
+    def process(options, **)
+      options["process"] = true
+    end
+  end
+
+  # 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
+    # result[:valid].must_be_nil
+    result["policy.default"].inspect.must_equal %{<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"
+  end
+end