trailblazer 2.1.0.beta4 → 2.1.0.beta5

data/test/docs/guard_test.rb

@@ -1,162 +0,0 @@
-require "test_helper"
-
-#--
-# with proc
-class DocsGuardProcTest < Minitest::Spec
-  #:proc
-  class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options, pass:, **) { pass } )
-    #~pipeonly
-    step :process
-
-    def process(options, **)
-      options["x"] = true
-    end
-    #~pipeonly end
-  end
-  #:proc end
-
-  it { Create.(pass: false)["x"].must_be_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 { Trailblazer::Operation::Inspect.(New).must_equal %{[>policy.default.eval,>process]} }
-end
-
-#---
-# with Callable
-class DocsGuardTest < Minitest::Spec
-  #:callable
-  class MyGuard
-    include Uber::Callable
-
-    def call(options, pass:, **)
-      pass
-    end
-  end
-  #:callable end
-
-  #:callable-op
-  class Create < Trailblazer::Operation
-    step Policy::Guard( MyGuard.new )
-    #~pipe-only
-    step :process
-
-    def process(options, **)
-      options[:x] = true
-    end
-    #~pipe-only end
-  end
-  #:callable-op end
-
-  it { Create.(pass: false)[:x].must_be_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, pass:, **)
-      pass
-    end
-    #~pipe-onlyy
-    step :process
-
-    def process(options, **)
-      options["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 { Trailblazer::Operation::Inspect.(Create).must_equal %{[>policy.default.eval,>model!]} }
-  it do
-    #:before-pipe
-      Trailblazer::Operation::Inspect.(Create, 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 { Operation::Inspect.(Create).must_equal %{[>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.(params: {})
-    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.(params: { 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.(params: {})
-    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.(params: { id: 1 })
-
-    #:show-ok
-    result = Show.(params: { 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

data/test/docs/nested_test.rb

@@ -1,300 +0,0 @@
-require "test_helper"
-
-class DocsNestedOperationTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find(id)
-      return new(1, "Bristol") if id == 1
-    end
-  end
-
-  #---
-  #- nested operations
-  #:edit
-  class Edit < Trailblazer::Operation
-    extend ClassDependencies
-    extend Contract::DSL
-
-    contract do
-      property :title
-    end
-
-    step Model( Song, :find )
-    step Contract::Build()
-  end
-  #:edit end
-
-    # step Nested( Edit ) #, "policy.default" => self["policy.create"]
-  #:update
-  class Update < Trailblazer::Operation
-    step Nested( Edit )
-    # step ->(options, **) { puts options.keys.inspect }
-    step Contract::Validate()
-
-    step Contract::Persist( method: :sync )
-  end
-  #:update end
-
-  # puts Update["pipetree"].inspect(style: :rows)
-
-  #-
-  # Edit allows grabbing model and contract
-  it do
-  #:edit-call
-  result = Edit.(params: {id: 1})
-
-  result[:model]            #=> #<Song id=1, title=\"Bristol\">
-  result["contract.default"] #=> #<Reform::Form ..>
-  #:edit-call end
-    result.inspect(:model).must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Bristol\">] >}
-    result["contract.default"].model.must_equal result[:model]
-  end
-
-#- test Edit circuit-level.
-it do
-  signal, (result, _) = Edit.__call__( [Trailblazer::Context( params: {id: 1} ), {}] )
-  result[:model].inspect.must_equal %{#<struct DocsNestedOperationTest::Song id=1, title=\"Bristol\">}
-end
-
-  #-
-  # Update also allows grabbing Edit/model and Edit/contract
-  it do
-  #:update-call
-  result = Update.(params: {id: 1, title: "Call It A Night"})
-
-  result[:model]            #=> #<Song id=1 , title=\"Call It A Night\">
-  result["contract.default"] #=> #<Reform::Form ..>
-  #:update-call end
-    result.inspect(:model).must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Call It A Night\">] >}
-    result["contract.default"].model.must_equal result[:model]
-  end
-
-  #-
-  # Edit is successful.
-  it do
-    result = Update.(params: { id: 1, title: "Miami" }, current_user: Module)
-    result.inspect(:model).must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title="Miami">] >}
-  end
-
-  # Edit fails
-  it do
-    Update.(params: {id: 2}).inspect(:model).must_equal %{<Result:false [nil] >}
-  end
-end
-
-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
-
-  it { MultiplyByPi.("x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
-
-  it do
-    #:input-result
-    result = MultiplyByPi.("x" => 9)
-    result["product"] #=> [28.27431]
-    #:input-result end
-  end
-end
-
-class NestedInputCallable < Minitest::Spec
-  Multiplier = NestedInput::Multiplier
-
-  #:input-callable
-  class MyInput
-    def self.call(options, **)
-      {
-        "y" => options["pi_constant"],
-        "x" => options["x"]
-      }
-    end
-  end
-  #:input-callable end
-
-  #:input-callable-op
-  class MultiplyByPi < Trailblazer::Operation
-    step ->(options, **) { options["pi_constant"] = 3.14159 }
-    step Nested( Multiplier, input: MyInput )
-  end
-  #:input-callable-op end
-
-  it { MultiplyByPi.("x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
-end
-
-#---
-#- Nested( .., output: )
-class NestedOutput < Minitest::Spec
-  Edit = DocsNestedOperationTest::Edit
-
-  #:output
-  class Update < Trailblazer::Operation
-    step Nested( Edit, output: ->( ctx, ** ) do
-      {
-        "contract.my" => ctx["contract.default"],
-        model:           ctx[:model]
-      }
-    end )
-    step Contract::Validate( name: "my" )
-    step Contract::Persist( method: :sync, name: "my" )
-  end
-  #:output end
-
-  it { Update.( params: {id: 1, title: "Call It A Night"} ).inspect(:model, "contract.default").
-      must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Call It A Night\">, nil] >} }
-
-  it do
-    result = Update.( params: {id: 1, title: "Call It A Night"} )
-
-    result[:model]            #=> #<Song id=1 , title=\"Call It A Night\">
-  end
-end
-
-#---
-# Nested( ->{} )
-class NestedWithCallableTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-
-  module Song::Contract
-    class Create < Reform::Form
-      property :title
-    end
-  end
-
-  User = Struct.new(:is_admin) do
-    def admin?
-      !! is_admin
-    end
-  end
-
-  class Create < Trailblazer::Operation
-    step Nested( ->(options, current_user:nil, **) { current_user.admin? ? Admin : NeedsModeration })
-
-    class NeedsModeration < Trailblazer::Operation
-      step Model( Song, :new )
-      step Contract::Build( constant: Song::Contract::Create )
-      step Contract::Validate()
-      step :notify_moderator!
-
-      def notify_moderator!(options, **)
-        #~noti
-        options["x"] = true
-        #~noti end
-      end
-    end
-
-    class Admin < Trailblazer::Operation # TODO: test if current_user is passed in.
-
-    end
-  end
-
-  let (:admin) { User.new(true) }
-  let (:anonymous) { User.new(false) }
-
-  it { Create.(params: {}, current_user: anonymous).inspect("x").must_equal %{<Result:true [true] >} }
-  it { Create.(params: {}, current_user: admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
-
-  #---
-  #:method
-  class Update < Trailblazer::Operation
-    step Nested( :build! )
-
-    def build!(options, current_user:nil, **)
-        current_user.admin? ? Create::Admin : Create::NeedsModeration
-    end
-  end
-  #:method end
-
-  it { Update.(params: {}, current_user: anonymous).inspect("x").must_equal %{<Result:true [true] >} }
-  it { Update.(params: {}, current_user: admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
-
-  #---
-  #:callable-builder
-  class MyBuilder
-    def self.call(options, current_user:nil, **)
-      current_user.admin? ? Create::Admin : Create::NeedsModeration
-    end
-  end
-  #:callable-builder end
-
-  #:callable
-  class Delete < Trailblazer::Operation
-    step Nested( MyBuilder )
-    # ..
-  end
-  #:callable end
-
-  it { Delete.(params: {}, current_user: anonymous).inspect("x").must_equal %{<Result:true [true] >} }
-  it { Delete.(params: {}, current_user: admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
-end
-
-class NestedWithCallableAndInputTest < Minitest::Spec
-  Memo = Struct.new(:title, :text, :created_by)
-
-  class Memo::Upsert < Trailblazer::Operation
-    step Nested( :operation_class, input: :input_for_create )
-
-    def operation_class( ctx, ** )
-      ctx[:id] ? Update : Create
-    end
-
-    # only let :title pass through.
-    def input_for_create( ctx )
-      { title: ctx[:title] }
-    end
-
-    class Create < Trailblazer::Operation
-      step :create_memo
-
-      def create_memo( ctx, ** )
-        ctx[:model] = Memo.new(ctx[:title], ctx[:text], :create)
-      end
-    end
-
-    class Update < Trailblazer::Operation
-      step :find_by_title
-
-      def find_by_title( ctx, ** )
-        ctx[:model] = Memo.new(ctx[:title], ctx[:text], :update)
-      end
-    end
-  end
-
-  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
-
-  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>] >}
-  end
-end
-
-# builder: Nested + deviate to left if nil / skip_track if true
-
-#---
-# automatic :name
-class NestedNameTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    class Present < Trailblazer::Operation
-      # ...
-    end
-
-    step Nested( Present )
-    # ...
-  end
-
-  it { Operation::Inspect.(Create).must_equal %{[>>Nested(NestedNameTest::Create::Present)]} }
-end

data/test/docs/policy_test.rb

@@ -1,2 +0,0 @@
-# add anything to result
-# insert any options into constructor

data/test/docs/pundit_test.rb

@@ -1,133 +0,0 @@
-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