trailblazer 2.1.0.beta4 → 2.1.0.beta5

data/test/nested_test.rb

@@ -1,293 +0,0 @@
-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/contract_test.rb

@@ -1,290 +0,0 @@
-require "test_helper"
-
-# class ContractExtractMacroTest < Minitest::Spec
-#   class Create < Trailblazer::Operation
-#     step Contract::Validate::Extract( key: "song", params_path: "x" )
-#   end
-
-#   it { Trailblazer::Operation::Inspect.(Create).must_equal %{[>x]} }
-#   it { Create.({}).inspect("x").must_equal %{<Result:false [nil] >} }
-#   it { Create.({ "song" => Object }).inspect("x").must_equal %{<Result:true [Object] >} }
-# end
-
-class ContractTest < Minitest::Spec
-  Song = Struct.new(:title)
-#   # generic form for testing.
-#   class Form
-#     def initialize(model, options={})
-#       @inspect = "#{self.class}: #{model} #{options.inspect}"
-#     end
-
-#     def validate
-#       @inspect
-#     end
-#   end
-
-#   # TODO: in all step tests.
-#   describe "dependency injection" do
-#     class Delete < Trailblazer::Operation
-#       include Contract::Step
-#     end
-
-#     class Follow < Trailblazer::Operation
-#       include Contract::Step
-#     end
-
-#     # inject contract instance via constructor.
-#     it { Delete.({}, "contract" => "contract/instance")["contract"].must_equal "contract/instance" }
-#     # inject contract class.
-#     it { Follow.({}, "contract.default.class" => Form)["contract"].class.must_equal Form }
-#   end
-
-
-#   # contract(model, [admin: true]).validate
-#   class Create < Trailblazer::Operation
-#     include Test::ReturnProcess
-#     include Contract::Explicit
-
-#     def call(options:false)
-#       return contract(model: Object, options: { admin: true }).validate if options
-#       contract(model: Object).validate
-#     end
-#   end
-
-#   # inject class, pass in model and options when constructing.
-#   # contract(model)
-#   it { Create.({}, "contract.default.class" => Form).must_equal "ContractTest::Form: Object {}" }
-#   # contract(model, options)
-#   it { Create.({ options: true }, "contract.default.class" => Form).must_equal "ContractTest::Form: Object {:admin=>true}" }
-
-#   # ::contract Form
-#   # contract(model).validate
-#   class Update < Trailblazer::Operation
-#     include Test::ReturnProcess
-#     include Contract::Explicit
-
-#      = Form
-
-#     def call(*)
-#       contract.validate
-#     end
-
-#     include Model( :Builder
-# )    def model!(*)
-#       Object
-#     end
-#   end
-
-#   # use the class contract.
-#   it { Update.().must_equal "ContractTest::Form: Object {}" }
-#   # injected contract overrides class.
-#   it { Update.({}, "contract.default.class" => Injected = Class.new(Form)).must_equal "ContractTest::Injected: Object {}" }
-
-#   # passing Constant into #contract
-#   # contract(Object.new, { title: "Bad Feeling" }, Contract)
-#   class Operation < Trailblazer::Operation
-#     include Contract::Explicit
-
-#     class Contract < Reform::Form
-#       property :title, virtual: true
-#     end
-
-#     def process(params)
-#       contract(model: Object.new, options: { title: "Bad Feeling" }, contract_class: Contract)
-
-#       validate(params)
-#     end
-#   end
-
-#   # allow using #contract to inject model, options and class.
-#   it do
-#     contract = Operation.(id: 1)["contract"]
-#     contract.title.must_equal "Bad Feeling"
-#     contract.must_be_instance_of Operation::Contract
-#   end
-
-#   # allow using #contract before #validate.
-#   class Upsert < Trailblazer::Operation
-#     include Contract::Explicit
-
-#     contract do
-#       property :id
-#       property :title
-#       property :length
-#     end
-
-#     def process(params)
-#       self["model"] = Struct.new(:id, :title, :length).new
-#       contract.id = 1
-#       validate(params) { contract.length = 3 }
-#     end
-#   end
-
-#   it do
-#     contract = Upsert.(title: "Beethoven")["contract"]
-#     contract.id.must_equal 1
-#     contract.title.must_equal "Beethoven"
-#     contract.length.must_equal 3
-#   end
-# end
-
-#---
-#- validate
-class ValidateTest < Minitest::Spec
-
-  #---
-  # Contract::Validate[]
-  class Update < Trailblazer::Operation
-    class Form < Reform::Form
-      property :title
-      validates :title, presence: true
-    end
-
-    step Model( Song, :new )
-    step Contract::Build( constant: Form )
-    step Contract::Validate() # generic validate call for you.
-
-    # include Procedural::Validate
-    ->(*) { validate(options["params"][:song]) } # <-- TODO
-  end
-
-  # success
-  it do
-    result = Update.(params: {title: "SVG"})
-    result.success?.must_equal true
-    result["result.contract.default"].success?.must_equal true
-    result["result.contract.default"].errors.messages.must_equal({})
-  end
-
-  # failure
-  it do
-    result = Update.(params: {title: nil})
-    result.success?.must_equal false
-    result["result.contract.default"].success?.must_equal false
-    result["result.contract.default"].errors.messages.must_equal({:title=>["can't be blank"]})
-  end
-
-  #---
-  # Contract::Validate[key: :song]
-  class Upsert < Trailblazer::Operation
-    class Form < Reform::Form
-      property :title
-      validates :title, presence: true
-    end
-
-    step Model( Song, :new ) # FIXME.
-    step Contract::Build( constant: Form )
-    step Contract::Validate( key: :song) # generic validate call for you.
-    # ->(*) { validate(options["params"][:song]) } # <-- TODO
-    step Contract::Persist( method: :sync )
-  end
-
-  # success
-  it { Upsert.(params: {song: { title: "SVG" }}).success?.must_equal true }
-  # failure
-  it { Upsert.(params: {song: { title: nil }}).success?.must_equal false }
-  # key not found
-  it { Upsert.(params: {}).success?.must_equal false }
-
-  #---
-  # contract.default.params gets set (TODO: change in 2.1)
-  it { Upsert.( params: {song: { title: "SVG" }})[:params].must_equal({:song=>{:title=>"SVG"}} ) }
-  it { Upsert.( params: {song: { title: "SVG" }})["contract.default.params"].must_equal({:title=>"SVG"} ) }
-
-  #---
-  #- inheritance
-  class New < Upsert
-  end
-
-  it { Trailblazer::Operation::Inspect.(New).must_equal %{[>model.build,>contract.build,>contract.default.validate,>persist.save]} }
-
-  #- overwriting Validate
-  class NewHit < Upsert
-    step Contract::Validate( key: :hit ), override: true
-  end
-
-  it { Trailblazer::Operation::Inspect.(NewHit).must_equal %{[>model.build,>contract.build,>contract.default.validate,>persist.save]} }
-  it { NewHit.(params: {:hit => { title: "Hooray For Me" }}).inspect(:model).must_equal %{<Result:true [#<struct ContractTest::Song title=\"Hooray For Me\">] >} }
-end
-
-# #---
-# # allow using #contract to inject model and arguments.
-# class OperationContractWithOptionsTest < Minitest::Spec
-#   # contract(model, title: "Bad Feeling")
-#   class Operation < Trailblazer::Operation
-#     include Contract::Explicit
-#     contract do
-#       property :id
-#       property :title, virtual: true
-#     end
-
-#     def process(params)
-#       model = Struct.new(:id).new
-
-#       contract(model: model, options: { title: "Bad Feeling" })
-
-#       validate(params)
-#     end
-#   end
-
-#   it do
-#     op = Operation.(id: 1)
-#     op["contract"].id.must_equal 1
-#     op["contract"].title.must_equal "Bad Feeling"
-#   end
-
-#   # contract({ song: song, album: album }, title: "Medicine Balls")
-#   class CompositionOperation < Trailblazer::Operation
-#     include Contract::Explicit
-#     contract do
-#       include Reform::Form::Composition
-#       property :song_id,    on: :song
-#       property :album_name, on: :album
-#       property :title,      virtual: true
-#     end
-
-#     def process(params)
-#       song  = Struct.new(:song_id).new(1)
-#       album = Struct.new(:album_name).new("Forever Malcom Young")
-
-#       contract(model: { song: song, album: album }, options: { title: "Medicine Balls" })
-
-#       validate(params)
-#     end
-#   end
-
-#   it do
-#     contract = CompositionOperation.({})["contract"]
-#     contract.song_id.must_equal 1
-#     contract.album_name.must_equal "Forever Malcom Young"
-#     contract.title.must_equal "Medicine Balls"
-#   end
-
-#   # validate(params, { song: song, album: album }, title: "Medicine Balls")
-#   class CompositionValidateOperation < Trailblazer::Operation
-#     include Contract::Explicit
-#     contract do
-#       include Reform::Form::Composition
-#       property :song_id,    on: :song
-#       property :album_name, on: :album
-#       property :title,      virtual: true
-#     end
-
-#     def process(params)
-#       song  = Struct.new(:song_id).new(1)
-#       album = Struct.new(:album_name).new("Forever Malcom Young")
-
-#       validate(params, model: { song: song, album: album }, options: { title: "Medicine Balls" })
-#     end
-#   end
-
-#   it do
-#     contract = CompositionValidateOperation.({})["contract"]
-#     contract.song_id.must_equal 1
-#     contract.album_name.must_equal "Forever Malcom Young"
-#     contract.title.must_equal "Medicine Balls"
-#   end
-end
-
-# TODO: full stack test with validate, process, save, etc.
-          # with model!