trailblazer 2.0.7 → 2.1.0.beta1

data/test/operation/callback_test.rb

@@ -1,70 +0,0 @@
-require 'test_helper'
-
-# callbacks are tested in Disposable::Callback::Group.
-class OperationCallbackTest < MiniTest::Spec
-  Song = Struct.new(:name)
-
-  #---
-  # with contract and disposable semantics
-  class Create < Trailblazer::Operation
-    extend Contract::DSL
-
-    contract do
-      property :name
-    end
-
-    step Model( Song, :new )
-    step Contract::Build()
-    step Contract::Validate()
-    step Callback( :default )
-
-
-    extend Callback::DSL
-
-    callback do
-      on_change :notify_me!
-      on_change :notify_you!
-    end
-
-
-    # TODO: always dispatch, pass params.
-
-    def dispatched
-      self["dispatched"] ||= []
-    end
-
-  private
-    def notify_me!(*)
-      dispatched << :notify_me!
-    end
-
-    def notify_you!(*)
-      dispatched << :notify_you!
-    end
-  end
-
-
-  class Update < Create
-    # TODO: allow skipping groups.
-    # skip_dispatch :notify_me!
-
-    callback do
-      remove! :on_change, :notify_me!
-    end
-  end
-
-  #---
-  #- inheritance
-  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>contract.build,>contract.default.validate,>callback.default]} }
-
-
-  it "invokes all callbacks" do
-    res = Create.({"name"=>"Keep On Running"})
-    res["dispatched"].must_equal [:notify_me!, :notify_you!]
-  end
-
-  it "does not invoke removed callbacks" do
-    res = Update.({"name"=>"Keep On Running"})
-    res["dispatched"].must_equal [:notify_you!]
-  end
-end

data/test/operation/dsl/callback_test.rb

@@ -1,106 +0,0 @@
-require "test_helper"
-
-class DslCallbackTest < MiniTest::Spec
-  module SongProcess
-    def _invocations
-      self["x"] ||= []
-    end
-
-    def self.included(includer)
-      includer.extend Trailblazer::Operation::Contract::DSL
-      includer.contract do
-        property :title
-      end
-      includer.| Trailblazer::Operation::Model[OpenStruct, :new]
-      includer.| Trailblazer::Operation::Contract::Build[includer["contract.default.class"]]
-      includer.| Trailblazer::Operation::Contract::Validate[]
-      includer.| Trailblazer::Operation::Callback[:default]
-    end
-  end
-
-  describe "inheritance across operations" do
-    class Operation < Trailblazer::Operation
-      extend Callback::DSL
-      include SongProcess
-
-      callback do
-        on_change :default!
-      end
-
-      class Admin < self
-        callback do
-          on_change :admin_default!
-        end
-
-        callback(:after_save) { on_change :after_save! }
-
-        def admin_default!(*); _invocations << :admin_default!; end
-        def after_save!(*);    _invocations << :after_save!; end
-
-        step Trailblazer::Operation::Callback[:after_save]
-      end
-
-      def default!(*); _invocations << :default!; end
-    end
-
-    it { Operation.({"title"=> "Love-less"})["x"].must_equal([:default!]) }
-    it { Operation::Admin.({"title"=> "Love-less"})["x"].must_equal([:default!, :admin_default!, :after_save!]) }
-  end
-
-  describe "Op.callback :after_save, AfterSaveCallback" do
-    class AfterSaveCallback < Disposable::Callback::Group
-      on_change :after_save!
-
-      def after_save!(twin, options)
-        options[:operation]._invocations << :after_save!
-      end
-    end
-
-    class OpWithExternalCallback < Trailblazer::Operation
-      include SongProcess
-      extend Callback::DSL
-      callback :after_save, AfterSaveCallback
-
-      step Callback[:after_save]
-    end
-
-    it { OpWithExternalCallback.("title"=>"Thunder Rising").must_equal([:after_save!]) }
-  end
-
-  describe "Op.callback :after_save, AfterSaveCallback do .. end" do
-    class DefaultCallback < Disposable::Callback::Group
-      on_change :default!
-
-      def default!(twin, options)
-        options[:operation]._invocations << :default!
-      end
-    end
-
-    class OpUsingCallback < Trailblazer::Operation
-      extend Callback::DSL
-      include SongProcess
-      callback :default, DefaultCallback
-    end
-
-    class OpExtendingCallback < Trailblazer::Operation
-      extend Callback::DSL
-      include SongProcess
-      callback :default, DefaultCallback do
-        on_change :after_save!
-
-        def default!(twin, options)
-          options[:operation]._invocations << :extended_default!
-        end
-
-        def after_save!(twin, options)
-          options[:operation]._invocations << :after_save!
-        end
-      end
-    end
-
-    # this operation copies DefaultCallback and shouldn't run #after_save!.
-    it { OpUsingCallback.(title: "Thunder Rising")["x"].must_equal([:default!]) }
-    # this operation copies DefaultCallback, extends it and runs #after_save!.
-    it { OpExtendingCallback.(title: "Thunder Rising")["x"].must_equal([:extended_default!, :after_save!]) }
-  end
-end

data/test/operation/params_test.rb

@@ -1,36 +0,0 @@
-require "test_helper"
-require "trailblazer/operation/params"
-
-class OperationParamsTest < MiniTest::Spec
-  #---
-  # in call(params) and process(params), argument is always self["params"]
-  class Find < Trailblazer::Operation
-    def process(params); self["eql?"] = self["params"].object_id==params.object_id end
-  end
-  class Seek < Trailblazer::Operation
-    include Test::ReturnCall
-    def call(params); self["eql?"] = self["params"].object_id==params.object_id end
-  end
-
-
-  it { Find.({ id: 1 })["eql?"].must_equal true }
-  # self["params"] is what gets passed in.
-  it { Find.({ id: 1 })["params"].must_equal({ id: 1 }) }
-  it { Seek.({ id: 1 }).must_equal true }
-
-
-  #---
-  # change self["params"] via Operation#
-  class Create < Trailblazer::Operation
-    include Params
-    def process(params) self[:x] = params end
-    def params!(params); params.merge(garrett: "Rocks!") end
-  end
-
-  # allows you changing params in #setup_params!.
-  it {
-    result = Create.( id: 1 )
-    result["params"].inspect.must_equal %{{:id=>1, :garrett=>\"Rocks!\"}}
-    result["params.original"].inspect.must_equal %{{:id=>1}}
-  }
-end

data/test/operation/pipedream_test.rb

@@ -1,59 +0,0 @@
-require "test_helper"
-
-class PipedreamTest < Minitest::Spec
-  Song = Struct.new(:title)
-
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :title
-    end
-
-    class Auth
-      def initialize(user, model); @user, @model = user, model end
-      def user_and_model?; @user == Module && @model.class == Song end
-    end
-
-    # design principles:
-    # * include as less code as possible into the op class.
-    # * make the flow super explicit without making it cryptic (only 3 new operators)
-    # * avoid including DSL modules in favor of passing those configurations directly to the "step".
-
-
-
-    step         Model[ Song, :new ]      # model!)
-    step Policy::Guard[ ->(options){ options["current_user"] == ::Module } ]
-    step      Contract[ MyContract]
-    step        Policy[ Auth, :user_and_model?]
-    failure      Contract[ MyContract]
-
-    # step :model
-    # step :guard
-    # step :contract
-
-
-    # ok Model[Song, :new]      # model!)
-    # ok Policy::Guard[ ->(options){ options["current_user"] == ::Module } ]
-    # ok Contract[MyContract]
-    # fail Contract[MyContract]
-    # step> "contract"
-
-    # | :bla
-    # | ->
-
-  end
-
-  # TODO: test with contract constant (done).
-  #       test with inline contract.
-  #       test with override contract!.
-
-  it do
-    puts Create["pipetree"].inspect(style: :rows)
-    result = Create.({}, { "current_user" => Module })
-
-    result["model"].inspect.must_equal %{#<struct PipedreamTest::Song title=nil>}
-    result["result.policy"].success?.must_equal true
-    result["contract"].class.superclass.must_equal Reform::Form
-
-
-  end
-end

data/test/operation/pipetree_test.rb

@@ -1,104 +0,0 @@
-require "test_helper"
-
-# self["pipetree"] = ::Pipetree[
-#       Trailblazer::Operation::New,
-#       # SetupParams,
-#       Trailblazer::Operation::Model::Build,
-#       Trailblazer::Operation::Model::Assign,
-#       Trailblazer::Operation::Call,
-#     ]
-
-
-
-# def deserialize(*)
-#     super
-#     self.datetime = DateTime.parse("#{date} #{time}")
-#   end
-
-class PipetreeTest < Minitest::Spec
-  Song = Struct.new(:title)
-
-  class Create < Trailblazer::Operation
-    include Builder
-    include Pipetree # this will add the functions, again, unfortunately. definitely an error source.
-  end
-
-  it { Create["pipetree"].inspect.must_equal %{[>>Build,>>New,>>Call,Result::Build,>>New,>>Call,Result::Build]} }
-
-  #---
-  # playground
-  require "trailblazer/operation/policy"
-  require "trailblazer/operation/guard"
-
-  class Edit < Trailblazer::Operation
-    include Builder
-    include Policy::Guard
-    include Contract::Step
-    contract do
-      property :title
-      validates :title, presence: true
-    end
-
-
-    MyValidate = ->(input, options) { res= input.validate(options["params"]) { |f| f.sync } }
-    # we can have a separate persist step and wrap in transaction. where do we pass contract, though?
-    step MyValidate, before: Call #replace: Contract::ValidLegacySwitch
-    #
-    MyAfterSave = ->(input, options) { input["after_save"] = true }
-    success MyAfterSave, after: MyValidate
-
-    ValidateFailureLogger = ->(input, options) { input["validate fail"] = true }
-    failure ValidateFailureLogger, after: MyValidate
-
-    success ->(input, options) { input.process(options["params"]) }, replace: Call, name: "my.params"
-
-    include Model
-
-    LogBreach = ->(input, options) { input.log_breach! }
-
-    failure LogBreach, after: Policy::Evaluate
-
-    model Song
-    policy ->(*) { self["current_user"] }
-
-    def log_breach!
-      self["breach"] = true
-    end
-
-    def process(params)
-      self["my.valid"] = true
-    end
-
-    self["pipetree"]._insert(Contract::ValidLegacySwitch, {delete: true}, nil, nil)
-  end
-
-  puts Edit["pipetree"].inspect(style: :rows)
-
-  it { Edit["pipetree"].inspect.must_equal %{[>>operation.build,>>operation.new,&model.build,&policy.guard.evaluate,<LogBreach,>contract.build,&MyValidate,<ValidateFailureLogger,>MyAfterSave,>my.params["params"]]} }
-
-  # valid case.
-  it {
-    # puts "valid"
-  # puts Edit["pipetree"].inspect(style: :rows)
-    result = Edit.({ title: "Stupid 7" }, "current_user" => true)
-    # puts "success! #{result.inspect}"
-    result["my.valid"].must_equal true
-    result["breach"].must_equal nil
-    result["after_save"].must_equal true
-    result["validate fail"].must_equal nil
-  }
-  # beach! i mean breach!
-  it {
-    # puts "beach"
-  # puts Edit["pipetree"].inspect(style: :rows)
-    result = Edit.({})
-    # puts "@@@@@ #{result.inspect}"
-    result["my.valid"].must_equal nil
-    result["breach"].must_equal true
-    result["validate fail"].must_equal true
-    result["after_save"].must_equal nil
-  }
-end
-
-# TODO: show the execution path in pipetree
-# unified result.contract, result.policy interface

data/test/operation/present_test.rb

@@ -1,24 +0,0 @@
-require "test_helper"
-
-require "trailblazer/operation/present"
-
-class PresentTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    include Test::ReturnCall
-    include Present
-
-    include Model::Builder
-    def model!(*); Object end
-
-    def call(params)
-      "#call run!"
-    end
-  end
-
-  it do
-    result = Create.present
-    result["model"].must_equal Object
-  end
-
-  it { Create.().must_equal "#call run!" }
-end

data/test/operation/resolver_test.rb

@@ -1,47 +0,0 @@
-# require "test_helper"
-
-# class ResolverTest < Minitest::Spec
-#   Song = Struct.new(:id) do
-#     def self.find(id); new(id) end
-#   end
-
-#   class Auth
-#     def initialize(*args); @user, @model = *args 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
-
-#   class A < Trailblazer::Operation
-#     extend Builder::DSL
-#     builds ->(options) {
-#       return P if options["params"] == { some: "params", id:1 }
-#       return B if options["policy.default"].inspect == %{<Auth: user:Module, model:#<struct ResolverTest::Song id=3>>} # both user and model:id are set!
-#       return M if options["model"].inspect == %{#<struct ResolverTest::Song id=9>}
-#     }
-
-#     step Model( Song, :update ), before: "operation.new"
-#     step Policy::Pundit( Auth, :user_and_model? ), before: "operation.new"
-#     require "trailblazer/operation/resolver"
-#     step Resolver(), before: "operation.new"
-
-#     step :process
-
-#     class P < self; end
-#     class B < self; end
-#     class M < self; end
-
-#     def process(*); self["x"] = self.class end
-#   end
-
-#   it { A["pipetree"].inspect.must_equal %{[&model.build,&policy.default.eval,>>builder.call,>>operation.new,&process]} }
-
-#   it { r=A.({ some: "params", id: 1 }, { "current_user" => Module })
-#     puts r.inspect
-
-#      }
-#   it { A.({ some: "params", id: 1 }, { "current_user" => Module })["x"].must_equal A::P }
-#   it { A.({                 id: 3 }, { "current_user" => Module })["x"].must_equal A::B }
-#   it { A.({                 id: 9 }, { "current_user" => Module })["x"].must_equal A::M }
-# end