trailblazer 2.0.7 → 2.1.0

data/test/docs/dry_test.rb

@@ -1,31 +0,0 @@
-require "test_helper"
-require "dry/container"
-
-class DryContainerTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-
-  class MyContract < Reform::Form
-    property :title
-    validates :title, length: 2..33
-  end
-
-  my_container = Dry::Container.new
-  my_container.register("contract.default.class", MyContract)
-  # my_container.namespace("contract") do
-  #   register("create") { Array }
-  # end
-
-  #---
-  #- dependency injection
-  #- with Dry-container
-  class Create < Trailblazer::Operation
-    step Model( Song, :new )
-    step Contract::Build()
-    step Contract::Validate()
-    step Contract::Persist( method: :sync )
-  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">] >} }
-end

data/test/docs/fast_test.rb

@@ -1,164 +0,0 @@
-require "test_helper"
-
-class DocsFailFastOptionTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find_by(id); nil end
-  end
-
-  class MyContract < Reform::Form
-  end
-
-
-  #:ffopt
-  class Update < Trailblazer::Operation
-    step    Model( Song, :find_by )
-    failure :abort!,                                fail_fast: true
-    step    Contract::Build( constant: MyContract )
-    step    Contract::Validate( )
-    failure :handle_invalid_contract!  # won't be executed if #abort! is executed.
-
-    def abort!(options, params:, **)
-      options["result.model.song"] = "Something went wrong with ID #{params[:id]}!"
-    end
-    # ..
-  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 do
-  #:ffopt-res
-    result = Update.(id: 1)
-    result["result.model.song"] #=> "Something went wrong with ID 1!"
-  #:ffopt-res end
-  end
-end
-
-class DocsFailFastOptionWithStepTest < Minitest::Spec
-  Song = Class.new do
-    def self.find_by(*); Object end
-  end
-
-  #:ffopt-step
-  class Update < Trailblazer::Operation
-    step :empty_id?,             fail_fast: true
-    step Model( Song, :find_by )
-    failure :handle_empty_db!   # won't be executed if #empty_id? returns falsey.
-
-    def empty_id?(options, params:, **)
-      params[:id] # returns false if :id missing.
-    end
-  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 do
-  #:ffopt-step-res
-    result = Update.({ id: nil })
-
-    result.failure? #=> true
-    result["model"] #=> nil
-  #:ffopt-step-res end
-  end
-end
-
-class DocsPassFastWithStepOptionTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find_by(id); nil end
-  end
-
-  class MyContract < Reform::Form
-  end
-
-  #:pfopt-step
-  class Update < Trailblazer::Operation
-    step    Model( Song, :find_by )
-    failure :abort!,                                fail_fast: true
-    step    Contract::Build( constant: MyContract )
-    step    Contract::Validate( )
-    failure :handle_invalid_contract!  # won't be executed if #abort! is executed.
-
-    def abort!(options, params:, **)
-      options["result.model.song"] = "Something went wrong with ID #{params[:id]}!"
-    end
-    # ..
-  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 do
-  #:pfopt-step-res
-    result = Update.(id: 1)
-    result["result.model.song"] #=> "Something went wrong with ID 1!"
-  #:pfopt-step-res end
-  end
-end
-
-class DocsFailFastMethodTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find_by(id); nil end
-  end
-
-  #:ffmeth
-  class Update < Trailblazer::Operation
-    step :filter_params!         # emits fail_fast!
-    step Model( Song, :find_by )
-    failure :handle_fail!
-
-    def filter_params!(options, params:, **)
-      unless params[:id]
-        options["result.params"] = "No ID in params!"
-        return Railway.fail_fast!
-      end
-    end
-
-    def handle_fail!(options, **)
-      options["my.status"] = "Broken!"
-    end
-  end
-  #:ffmeth end
-
-  it { Update.({}).inspect("result.params", "my.status").must_equal %{<Result:false [\"No ID in params!\", nil] >} }
-  it do
-  #:ffmeth-res
-    result = Update.(id: 1)
-    result["result.params"] #=> "No ID in params!"
-    result["my.status"]     #=> nil
-  #:ffmeth-res end
-  end
-end
-
-class DocsPassFastMethodTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def save; end
-  end
-
-  class MyContract < Reform::Form
-  end
-
-  #:pfmeth
-  class Create < Trailblazer::Operation
-    step Model( Song, :new )
-    step :empty_model!                           # emits pass_fast!
-    step Contract::Build( constant: MyContract )
-    # ..
-
-    def empty_model!(options, is_empty:, model:, **)
-      return unless is_empty
-      model.save
-      Railway.pass_fast!
-    end
-  end
-  #:pfmeth end
-
-  it { Create.({ 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["model"] #=> #<Song id=nil, title=nil>
-  #:pfmeth-res end
-  end
-end
-
-# fail!
-# pass!

data/test/docs/guard_test.rb

@@ -1,169 +0,0 @@
-require "test_helper"
-
-#--
-# with proc
-class DocsGuardProcTest < Minitest::Spec
-  # test without KWs, only options.
-  class Update < Trailblazer::Operation
-    step Policy::Guard( ->(options) { options["params"][:pass] } )
-    step ->(options, *) { options["x"] = true }
-  end
-
-  it { Update.(pass: false)["x"].must_equal nil }
-  it { Update.(pass: true)["x"].must_equal true }
-  # TODO: test excp when current_user not available
-
-  #:proc
-  class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options, params:, **) { params[:pass] } )
-    #~pipeonly
-    step :process
-
-    def process(*)
-      self["x"] = true
-    end
-    #~pipeonly end
-  end
-  #:proc end
-
-  it { Create.(pass: false)["x"].must_equal nil }
-  it { Create.(pass: true)["x"].must_equal true }
-
-  #- result object, guard
-  it { Create.(pass: true)["result.policy.default"].success?.must_equal true }
-  it { Create.(pass: false)["result.policy.default"].success?.must_equal false }
-
-
-
-
-   #---
-  #- Guard inheritance
-  class New < Create
-    step Policy::Guard( ->(options, current_user:, **) { current_user } ), override: true
-  end
-
-  it { New["pipetree"].inspect.must_equal %{[>operation.new,>policy.default.eval,>process]} }
-end
-
-#---
-# with Callable
-class DocsGuardTest < Minitest::Spec
-  #:callable
-  class MyGuard
-    include Uber::Callable
-
-    def call(options, params:, **)
-      params[:pass]
-    end
-  end
-  #:callable end
-
-  #:callable-op
-  class Create < Trailblazer::Operation
-    step Policy::Guard( MyGuard.new )
-    #~pipe-only
-    step :process
-    def process(*); self[:x] = true; end
-    #~pipe-only end
-  end
-  #:callable-op end
-
-  it { Create.(pass: false)[:x].must_equal nil }
-  it { Create.(pass: true)[:x].must_equal true }
-end
-
-#---
-# with method
-class DocsGuardMethodTest < Minitest::Spec
-  #:method
-  class Create < Trailblazer::Operation
-    step Policy::Guard( :pass? )
-
-    def pass?(options, params:, **)
-      params[:pass]
-    end
-    #~pipe-onlyy
-    step :process
-    def process(*); self["x"] = true; end
-    #~pipe-onlyy end
-  end
-  #:method end
-
-  it { Create.(pass: false).inspect("x").must_equal %{<Result:false [nil] >} }
-  it { Create.(pass: true).inspect("x").must_equal %{<Result:true [true] >} }
-end
-
-#---
-# with name:
-class DocsGuardNamedTest < Minitest::Spec
-  #:name
-  class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options, current_user:, **) { current_user }, name: :user )
-    # ...
-  end
-  #:name end
-
-  it { Create.({}, "current_user" => nil   )["result.policy.user"].success?.must_equal false }
-  it { Create.({}, "current_user" => Module)["result.policy.user"].success?.must_equal true }
-
-  it {
-  #:name-result
-  result = Create.({}, "current_user" => true)
-  result["result.policy.user"].success? #=> true
-  #:name-result end
-  }
-end
-
-#---
-# dependency injection
-class DocsGuardInjectionTest < Minitest::Spec
-  #:di-op
-  class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options, current_user:, **) { current_user == Module } )
-  end
-  #:di-op end
-
-  it { Create.({}, "current_user" => Module).inspect("").must_equal %{<Result:true [nil] >} }
-  it {
-    result =
-  #:di-call
-  Create.({},
-    "current_user"        => Module,
-    "policy.default.eval" => Trailblazer::Operation::Policy::Guard.build(->(options) { false })
-  )
-  #:di-call end
-    result.inspect("").must_equal %{<Result:false [nil] >} }
-end
-
-#---
-# missing current_user throws exception
-class DocsGuardMissingKeywordTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options, current_user:, **) { current_user == Module } )
-  end
-
-  it { assert_raises(ArgumentError) { Create.() } }
-  it { Create.({}, "current_user" => Module).success?.must_equal true }
-end
-
-#---
-# before:
-class DocsGuardPositionTest < Minitest::Spec
-  #:before
-  class Create < Trailblazer::Operation
-    step :model!
-    step Policy::Guard( :authorize! ),
-      before: :model!
-  end
-  #:before end
-
-  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>policy.default.eval,>model!]} }
-  it do
-    #:before-pipe
-      puts Create["pipetree"].inspect(style: :rows) #=>
-       # 0 ========================>operation.new
-       # 1 ==================>policy.default.eval
-       # 2 ===============================>model!
-    #:before-pipe end
-  end
-end

data/test/docs/macro_test.rb

@@ -1,36 +0,0 @@
-require "test_helper"
-
-class DocsMacroTest < Minitest::Spec
-  #:simple
-  module Macro
-    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.
-    end
-  end
-  #:simple end
-
-  #:simple-op
-  class Create < Trailblazer::Operation
-    step Macro::MyPolicy( allowed_role: "manager" )
-    # ..
-  end
-  #:simple-op end
-
-=begin
-  it do
-  #:simple-pipe
-    puts Create["pipetree"].inspect(style: :rows) #=>
-     0 ========================>operation.new
-     1 ====================>my_policy.manager
-  #:simple-pipe end
-  end
-=end
-
-  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>my_policy.manager]} }
-end
-
-# injectable option
-# nested pipe
-# using macros in macros

data/test/docs/model_test.rb

@@ -1,75 +0,0 @@
-require "test_helper"
-
-class DocsModelTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find_by(id:nil)
-      id.nil? ? nil : new(id)
-    end
-
-    def self.[](id)
-      id.nil? ? nil : new(id+99)
-    end
-  end
-
-  #:op
-  class Create < Trailblazer::Operation
-    step Model( Song, :new )
-    # ..
-  end
-  #:op end
-
-  it do
-    #:create
-    result = Create.({})
-    result["model"] #=> #<struct Song id=nil, title=nil>
-    #:create end
-
-    result["model"].inspect.must_equal %{#<struct DocsModelTest::Song id=nil, title=nil>}
-  end
-
-  #:update
-  class Update < Trailblazer::Operation
-    step Model( Song, :find_by )
-    # ..
-  end
-  #:update end
-
-  it do
-    #:update-ok
-    result = Update.({ id: 1 })
-    result["model"] #=> #<struct Song id=1, title="Roxanne">
-    #:update-ok end
-
-    result["model"].inspect.must_equal %{#<struct DocsModelTest::Song id=1, title=nil>}
-  end
-
-  it do
-    #:update-fail
-    result = Update.({})
-    result["model"] #=> nil
-    result.success? #=> false
-    #:update-fail end
-
-    result["model"].must_be_nil
-    result.success?.must_equal false
-  end
-
-  #:show
-  class Show < Trailblazer::Operation
-    step Model( Song, :[] )
-    # ..
-  end
-  #:show end
-
-  it do
-    result = Show.({ id: 1 })
-
-    #:show-ok
-    result = Show.({ id: 1 })
-    result["model"] #=> #<struct Song id=1, title="Roxanne">
-    #:show-ok end
-
-    result.success?.must_equal true
-    result["model"].inspect.must_equal %{#<struct DocsModelTest::Song id=100, title=nil>}
-  end
-end