trailblazer 2.0.7 → 2.1.0

data/test/docs/nested_test.rb

@@ -1,334 +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 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 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.(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
-
-  #-
-  # Update also allows grabbing model and contract
-  it do
-  #:update-call
-  result = Update.(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.({ 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.(id: 2).inspect("model").must_equal %{<Result:false [nil] >}
-  end
-
-  #---
-  #- shared data
-  class B < Trailblazer::Operation
-    success ->(options) { options["can.B.see.it?"] = options["this.should.not.be.visible.in.B"] }
-    success ->(options) { options["can.B.see.current_user?"] = options["current_user"] }
-    success ->(options) { options["can.B.see.params?"] = options["params"] }
-    success ->(options) { options["can.B.see.A.class.data?"] = options["A.class.data"] }
-  end
-
-  class A < Trailblazer::Operation
-    self["A.class.data"] = true
-
-    success ->(options) { options["this.should.not.be.visible.in.B"] = true }
-    step Nested( B )
-  end
-
-  # mutual data from A doesn't bleed into B.
-  it { A.()["can.B.see.it?"].must_equal nil }
-  it { A.()["this.should.not.be.visible.in.B"].must_equal true }
-  # runtime dependencies are visible in B.
-  it { A.({}, "current_user" => Module)["can.B.see.current_user?"].must_equal Module }
-  it { A.({ a: 1 })["can.B.see.params?"].must_equal({ a: 1 }) }
-  # class data from A doesn't bleed into B.
-  it { A.()["can.B.see.A.class.data?"].must_equal nil }
-
-
-  # cr_result = Create.({}, "result" => result)
-  # puts cr_result["model"]
-  # puts cr_result["contract.default"]
-
-  #---
-  #- Nested( .., input: )
-  class C < Trailblazer::Operation
-    self["C.class.data"] = true
-
-    success ->(options) { options["this.should.not.be.visible.in.B"] = true }
-
-    step Nested( B, input: ->(options, runtime_data:, mutable_data:, **) {
-      runtime_data.merge( "this.should.not.be.visible.in.B" => mutable_data["this.should.not.be.visible.in.B"] )
-    } )
-  end
-
-  it { C.()["can.B.see.it?"].must_equal true }
-  it { C.()["this.should.not.be.visible.in.B"].must_equal true } # this IS visible since we use :input!
-  it { C.({}, "current_user" => Module)["can.B.see.current_user?"].must_equal Module }
-  it { C.()["can.B.see.A.class.data?"].must_equal nil }
-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, mutable_data:, runtime_data:, **) do
-      { "y" => mutable_data["pi_constant"],
-        "x" => runtime_data["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
-    extend Uber::Callable
-
-    def self.call(options, mutable_data:, runtime_data:, **)
-      {
-        "y" => mutable_data["pi_constant"],
-        "x" => runtime_data["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: ->(options, mutable_data:, **) do
-      {
-        "contract.my" => mutable_data["contract.default"],
-        "model"       => mutable_data["model"]
-      }
-    end )
-    step Contract::Validate( name: "my" )
-    step Contract::Persist( method: :sync, name: "my" )
-  end
-  #:output end
-
-  it { Update.( 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.( id: 1, title: "Call It A Night" )
-
-    result["model"]            #=> #<Song id=1 , title=\"Call It A Night\">
-  end
-end
-
-class NestedClassLevelTest < Minitest::Spec
-  #:class-level
-  class New < Trailblazer::Operation
-    step ->(options) { options["class"] = true }, before: "operation.new"
-    step ->(options) { options["x"] = true }
-  end
-
-  class Create < Trailblazer::Operation
-    step Nested( New )
-    step ->(options) { options["y"] = true }
-  end
-  #:class-level end
-
-  it { Create.().inspect("x", "y").must_equal %{<Result:true [true, true] >} }
-  it { Create.(); Create["class"].must_equal nil }
-end
-
-#---
-# Nested( ->{} )
-class NestedWithCallableTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-
-  class X < Trailblazer::Operation
-    step ->(options, params:, **) { options["params.original"] = params }
-    step ->(options) { options["x"] = true }
-  end
-
-  class Y < Trailblazer::Operation
-    step ->(options) { options["y"] = true }
-  end
-
-  class A < Trailblazer::Operation
-    step ->(options) { options["z"] = true }
-    step Nested( ->(options, *) { options["class"] } )
-  end
-
-  it { A.({ a: 1 }, "class" => X).inspect("x", "y", "z", "params.original").must_equal "<Result:true [true, nil, true, {:a=>1}] >" }
-  it { A.({}, "class" => Y).inspect("x", "y", "z").must_equal "<Result:true [nil, true, true] >" }
-  # it { Create.({}).inspect("x", "y", "z").must_equal "<Result:true [nil, true, true] >" }
-
-  class Song
-    module Contract
-      class Create < Reform::Form
-        property :title
-      end
-    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.({}, "current_user" => anonymous).inspect("x").must_equal %{<Result:true [true] >} }
-  it { Create.({}, "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.({}, "current_user" => anonymous).inspect("x").must_equal %{<Result:true [true] >} }
-  it { Update.({}, "current_user" => admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
-
-  #---
-  #:callable-builder
-  class MyBuilder
-    extend Uber::Callable
-
-    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.({}, "current_user" => anonymous).inspect("x").must_equal %{<Result:true [true] >} }
-  it { Delete.({}, "current_user" => admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
-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 { Create["pipetree"].inspect.must_equal %{[>operation.new,>Nested(NestedNameTest::Create::Present)]} }
-end

data/test/docs/operation_test.rb

@@ -1,408 +0,0 @@
-require "test_helper"
-
-class DocsOperationExampleTest < Minitest::Spec
-  Song = Struct.new(:id, :title, :created_by) do
-    def save; true; end
-  end
-  User = Struct.new(:name)
-
-  #:invocation-dep
-  class Create < Trailblazer::Operation
-    step     Model( Song, :new )
-    step     :assign_current_user!
-    # ..
-    def assign_current_user!(options)
-      options["model"].created_by = options["current_user"]
-    end
-  end
-  #:invocation-dep end
-
-  it do
-    current_user = User.new("Ema")
-  #:invocation-dep-call
-  result = Create.( { title: "Roxanne" }, "current_user" => current_user )
-  #:invocation-dep-call end
-
-  #:invocation-dep-res
-  result["current_user"] #=> #<User name="Ema">
-  result["model"]        #=> #<Song id=nil, title=nil, created_by=#<User name="Ema">>
-  #:invocation-dep-res end
-  end
-
-  it { Create.({ title: "Roxanne" }, "current_user" => Module).inspect("model").must_equal %{<Result:true [#<struct DocsOperationExampleTest::Song id=nil, title=nil, created_by=Module>] >} }
-
-  #:op
-  class Song::Create < Trailblazer::Operation
-    extend Contract::DSL
-
-    contract do
-      property :title
-      validates :title, presence: true
-    end
-
-    step     Model( Song, :new )
-    step     :assign_current_user!
-    step     Contract::Build()
-    step     Contract::Validate( )
-    failure  :log_error!
-    step     Contract::Persist(  )
-
-    def log_error!(options)
-      # ..
-    end
-
-    def assign_current_user!(options)
-      options["model"].created_by =
-        options["current_user"]
-    end
-  end
-  #:op end
-
-  it { Song::Create.({ }).inspect("model").must_equal %{<Result:false [#<struct DocsOperationExampleTest::Song id=nil, title=nil, created_by=nil>] >} }
-  it { Song::Create.({ title: "Nothin'" }, "current_user"=>Module).inspect("model").must_equal %{<Result:true [#<struct DocsOperationExampleTest::Song id=nil, title="Nothin'", created_by=Module>] >} }
-end
-
-class DndTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step     :authorize!
-    failure  :auth_err!
-    step     :save!
-    failure Wrap
-  end
-end
-
-class DocsResultTest < Minitest::Spec
-  Song = Struct.new(:id, :title, :created_by) do
-    def save; true; end
-  end
-
-  #:step-options
-  class Song::Create < Trailblazer::Operation
-    step     :model!
-    step     :assign!
-    step     :validate!
-
-    def model!(options, current_user:, **)
-      options["model"] = Song.new
-      options["model"].created_by = current_user
-    end
-
-    def assign!(*, params:, model:, **)
-      model.title= params[:title]
-    end
-
-    #:step-val
-    def validate!(options, model:, **)
-      options["result.validate"] = ( model.created_by && model.title )
-    end
-    #:step-val end
-  end
-  #:step-options end
-
-  it do
-    current_user = Struct.new(:email).new("nick@trailblazer.to")
-  #:step-res
-  result = Song::Create.({ title: "Roxanne" }, "current_user" => current_user)
-
-  result["model"] #=> #<Song title="Roxanne", "created_by"=<User ...>
-  result["result.validate"] #=> true
-  #:step-res end
-
-    result.inspect("current_user", "model").must_equal %{<Result:true [#<struct email=\"nick@trailblazer.to\">, #<struct DocsResultTest::Song id=nil, title="Roxanne", created_by=#<struct email=\"nick@trailblazer.to\">>] >}
-
-  #:step-binary
-  result.success? #=> true
-  result.failure? #=> falsee
-  #:step-binary end
-
-  #:step-dep
-  result["current_user"] #=> <User ...>
-  #:step-dep end
-
-  #:step-inspect
-  result.inspect("current_user", "model") #=> "<Result:true [#<User email=\"nick@tra... "
-  #:step-inspect end
-  end
-end
-
-class DocsDependencyTest < Minitest::Spec
-  Song = Struct.new(:id, :title, :created_by) do
-    def save; true; end
-  end
-  Hit = Struct.new(:id)
-
-  #:dep-op
-  class Song::Create < Trailblazer::Operation
-    self["my.model.class"] = Song
-
-    #~dep-pipe
-    step :model!
-
-    def model!(options, **)
-      options["my.model"] =           # setting runtime data.
-        options["my.model.class"].new # reading class data at runtime.
-    end
-    #~dep-pipe end
-  end
-  #:dep-op end
-
-  it do
-    #:dep-op-class
-    Song::Create["my.model.class"] #=> Song
-    #:dep-op-class end
-
-    #:dep-op-res
-    result = Song::Create.({})
-
-    result["my.model.class"] #=> Song
-    result["my.model"] #=> #<Song title=nil>
-    #:dep-op-res end
-
-    Song::Create["my.model.class"].must_equal Song
-    result["my.model.class"].must_equal Song
-    result["my.model"].inspect.must_equal %{#<struct DocsDependencyTest::Song id=nil, title=nil, created_by=nil>}
-  end
-
-  it do
-    #:dep-di
-    result = Song::Create.({}, "my.model.class" => Hit)
-
-    result["my.model"] #=> #<Hit id=nil>
-    #:dep-di end
-    result["my.model"].inspect.must_equal %{#<struct DocsDependencyTest::Hit id=nil>}
-  end
-end
-
-
-
-class DocsOperationAPIExampleTest < Minitest::Spec
-  Song = Struct.new(:id, :title, :created_by) do
-    def save; true; end
-  end
-
-  class MyContract < Reform::Form
-    property :title
-    validates :title, presence: true
-  end
-
-  #:op-api
-  class Song::Create < Trailblazer::Operation
-    step    Model( Song, :new )
-    step    :assign_current_user!
-    step    Contract::Build( constant: MyContract )
-    step    Contract::Validate()
-    failure :log_error!
-    step    Contract::Persist()
-
-    def log_error!(options)
-      # ..
-    end
-
-    def assign_current_user!(options)
-      options["model"].created_by =
-        options["current_user"]
-    end
-  end
-  #:op-api end
-
-  it { Song::Create.({ }).inspect("model").must_equal %{<Result:false [#<struct DocsOperationAPIExampleTest::Song id=nil, title=nil, created_by=nil>] >} }
-  it { Song::Create.({ title: "Nothin'" }, "current_user"=>Module).inspect("model").must_equal %{<Result:true [#<struct DocsOperationAPIExampleTest::Song id=nil, title="Nothin'", created_by=Module>] >} }
-end
-
-
-class DocsOperationInheritanceTest < Minitest::Spec
-  Song = Struct.new(:id, :title, :created_by) do
-    def save; true; end
-  end
-
-  class MyContract < Reform::Form
-    property :title
-    validates :title, presence: true
-  end
-
-  #:inh-new
-  class New < Trailblazer::Operation
-    step Model( Song, :new )
-    step Contract::Build( constant: MyContract )
-  end
-  #:inh-new end
-
-  puts New["pipetree"].inspect(style: :row)
-=begin
-  #:inh-new-pipe
-   0 =======================>>operation.new
-   1 ==========================&model.build
-   2 =======================>contract.build
-  #:inh-new-pipe end
-=end
-
-  #:inh-create
-  class Create < New
-    step Contract::Validate()
-    step Contract::Persist()
-  end
-  #:inh-create end
-
-  puts Create["pipetree"].inspect(style: :row)
-=begin
-  #:inh-create-pipe
-   0 =======================>>operation.new
-   1 ==========================&model.build
-   2 =======================>contract.build
-   3 ==============&contract.default.params
-   4 ============&contract.default.validate
-   5 =========================&persist.save
-  #:inh-create-pipe end
-=end
-
-  module MyApp
-  end
-
-  #:override-app
-  module MyApp::Operation
-    class New < Trailblazer::Operation
-      extend Contract::DSL
-
-      contract do
-        property :title
-      end
-
-      step Model( nil, :new )
-      step Contract::Build()
-    end
-  end
-  #:override-app end
-
-  #:override-new
-  class Song::New < MyApp::Operation::New
-    step Model( Song, :new ), override: true
-  end
-  #:override-new end
-
-  puts Song::New["pipetree"].inspect(style: :row)
-=begin
-  #:override-pipe
-  Song::New["pipetree"].inspect(style: :row)
-   0 =======================>>operation.new
-   1 ==========================&model.build
-   2 =======================>contract.build
-  #:override-pipe end
-=end
-
-  it do
-    Song::New["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>contract.build]}
-    Song::New.().inspect("model").must_equal %{<Result:true [#<struct DocsOperationInheritanceTest::Song id=nil, title=nil, created_by=nil>] >}
-  end
-end
-
-class DocsOperationStepOptionsTest < Minitest::Spec
-  Song = Struct.new(:title) do
-    def self.find_by(*)
-      nil
-    end
-  end
-
-  class AutomaticNameTest < Minitest::Spec
-    #:name-auto
-    class New < Trailblazer::Operation
-      step Model( Song, :new )
-    end
-    #:name-auto end
-
-    puts New["pipetree"].inspect(style: :row)
-=begin
-  #:name-auto-pipe
-   0 =======================>>operation.new
-   1 ==========================&model.build
-  #:name-auto-pipe end
-=end
-
-    #:replace-inh
-    class Update < New
-      step Model(Song, :find_by), replace: "model.build"
-    end
-    #:replace-inh end
-
-    puts Update["pipetree"].inspect(style: :row)
-=begin
-  #:replace-inh-pipe
-   0 =======================>>operation.new
-   2 ==========================&model.build
-  #:replace-inh-pipe end
-=end
-
-    it { Update.({}).inspect("model").must_equal %{<Result:false [nil] >} }
-
-
-#     #:delete-inh
-#     class Noop < New
-#       step nil, delete: "model.build"
-#     end
-#     #:delete-inh end
-
-# puts "yo"
-#     puts Update["pipetree"].inspect(style: :row)
-# =begin
-#   #:delete-inh-pipe
-#    0 =======================>>operation.new
-#    2 ==========================&model.build
-#   #:delete-inh-pipe end
-# =end
-
-#     it { Noop.({}).inspect("model").must_equal %{<Result:false [nil] >} }
-  end
-
-  class ManualNameTest < Minitest::Spec
-    #:name-manu
-    class New < Trailblazer::Operation
-      step Model( Song, :new ), name: "build.song.model"
-      step :validate_params!,   name: "my.params.validate"
-      # ..
-    end
-    #:name-manu end
-
-    puts New["pipetree"].inspect(style: :row)
-=begin
-  #:name-manu-pipe
-   0 =======================>>operation.new
-   1 =====================&build.song.model
-   2 ===================&my.params.validate
-  #:name-manu-pipe end
-=end
-  end
-
-  class BeforeTest < Minitest::Spec
-    #:pos-before
-    class New < Trailblazer::Operation
-      step Model( Song, :new )
-      step :validate_params!,   before: "model.build"
-      # ..
-    end
-    #:pos-before end
-
-    puts New["pipetree"].inspect(style: :row)
-=begin
-  #:pos-before-pipe
-   0 =======================>>operation.new
-   1 =====================&validate_params!
-   2 ==========================&model.build
-  #:pos-before-pipe end
-=end
-
-    #:pos-inh
-    class Create < New
-      step :policy!, after: "operation.new"
-    end
-    #:pos-inh end
-
-    puts Create["pipetree"].inspect(style: :row)
-=begin
-  #:pos-inh-pipe
-   0 =======================>>operation.new
-   1 ==============================&policy!
-   2 =====================&validate_params!
-   3 ==========================&model.build
-  #:pos-inh-pipe end
-=end
-  end
-end