trailblazer 1.1.2 → 2.0.0.beta1

data/test/operation/guard_test.rb

@@ -1,152 +1,6 @@
 require "test_helper"
-require "trailblazer/operation/policy"
 
-class OpPolicyGuardTest < MiniTest::Spec
-  Song = Struct.new(:name)
 
-  class Create < Trailblazer::Operation
-    include Policy::Guard
 
-    def model!(*)
-      Song.new
-    end
 
-    policy do |params|
-      model.is_a?(Song) and params[:valid]
-    end
-
-    def process(*)
-    end
-  end
-
-  # valid.
-  it do
-    op = Create.(valid: true)
-  end
-
-  # invalid.
-  it do
-    assert_raises Trailblazer::NotAuthorizedError do
-      op = Create.(valid: false)
-    end
-  end
-
-
-  describe "inheritance" do
-    class Update < Create
-      policy do |params|
-        params[:valid] == "correct"
-      end
-    end
-
-    class Delete < Create
-    end
-
-    it do
-      Create.(valid: true).wont_equal nil
-      Delete.(valid: true).wont_equal nil
-      Update.(valid: "correct").wont_equal nil
-    end
-  end
-
-
-  describe "no policy defined, but included" do
-    class Show < Trailblazer::Operation
-      include Policy::Guard
-
-      def process(*)
-      end
-    end
-
-    it { Show.({}).wont_equal nil }
-  end
-
-
-  describe "#params!" do
-    class Index < Trailblazer::Operation
-      include Policy::Guard
-
-      # make sure the guard receives the correct params.
-      policy { |params| params[:valid] == "true" }
-
-      def params!(params)
-        { valid: params }
-      end
-
-      def process(*)
-      end
-    end
-
-    it { Index.("true").wont_equal nil }
-    it { assert_raises(Trailblazer::NotAuthorizedError) { Index.(false).wont_equal nil } }
-  end
-
-  describe "with Callable" do
-    class Find < Trailblazer::Operation
-      include Policy::Guard
-
-      class Guardian
-        include Uber::Callable
-
-        def call(context, params)
-          params == "true"
-        end
-      end
-
-      policy Guardian.new
-
-      def process(*)
-      end
-    end
-
-    it { Find.("true").wont_equal nil }
-    it { assert_raises(Trailblazer::NotAuthorizedError) { Find.(false).wont_equal nil } }
-  end
-
-  describe "with Proc" do
-    class Follow < Trailblazer::Operation
-      include Policy::Guard
-
-      policy ->(params) { params == "true" } # TODO: is this really executed in op context?
-
-      def process(*)
-      end
-    end
-
-    it { Follow.("true").wont_equal nil }
-    it { assert_raises(Trailblazer::NotAuthorizedError) { Follow.(false).wont_equal nil } }
-  end
-end
-
-class OpBuilderDenyTest < MiniTest::Spec
-  Song = Struct.new(:name)
-
-  class Create < Trailblazer::Operation
-    include Deny
-
-    builds do |params|
-      deny! unless params[:valid]
-    end
-
-    def process(params)
-    end
-  end
-
-  class Update < Create
-    builds -> (params) do
-      deny! unless params[:valid]
-    end
-  end
-
-  # valid.
-  it do
-    op = Create.(valid: true)
-  end
-
-  # invalid.
-  it do
-    assert_raises Trailblazer::NotAuthorizedError do
-      op = Create.(valid: false)
-    end
-  end
-end
+# FIXME: what about block passed to ::policy?

data/test/operation/model_test.rb

@@ -0,0 +1,105 @@
+require "test_helper"
+
+class ModelTest < Minitest::Spec
+  Song = Struct.new(:id) do
+    def self.find(id); new(id) end
+    def self.find_by(id:nil); id.nil? ? nil : new(id) end
+  end
+
+  #---
+  # use Model semantics, no customizations.
+  class Create < Trailblazer::Operation
+    self.| Model Song, :new
+  end
+
+  # :new new.
+  it { Create.({})["model"].inspect.must_equal %{#<struct ModelTest::Song id=nil>} }
+
+  class Update < Create
+    self.~ Model :update # DISCUSS: do we need the ~ operator?
+  end
+
+  # :find it
+  it { Update.({ id: 1 })["model"].inspect.must_equal %{#<struct ModelTest::Song id=1>} }
+
+  #- inheritance
+  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&model.build]} }
+
+  # override #model with Model included.
+  class Upsert < Create
+    def model!(params); params.to_s end
+  end
+
+  it { Upsert.(id: 9)["model"].must_equal %{{:id=>9}} }
+
+  #---
+  # :find_by, exceptionless.
+  class Find < Trailblazer::Operation
+    self.| Model Song, :find_by
+    self.| :process
+
+    def process(*); self["x"] = true end
+  end
+
+  # can't find model.
+  #- result object, model
+  it do
+    Find.(id: nil)["result.model"].failure?.must_equal true
+    Find.(id: nil)["x"].must_equal nil
+    Find.(id: nil).failure?.must_equal true
+  end
+
+  #- result object, model
+  it do
+    Find.(id: 9)["result.model"].success?.must_equal true
+    Find.(id: 9)["x"].must_equal true
+    Find.(id: 9)["model"].inspect.must_equal %{#<struct ModelTest::Song id=9>}
+  end
+
+  #---
+  # override #model!, without any Model inclusions.
+  class Delete < Trailblazer::Operation
+    self.| Model :model!
+    def model!(params); params.to_s end
+  end
+
+  it { Delete.(id: 1)["model"].must_equal %{{:id=>1}} }
+
+  #---
+  # creating the model before operation instantiation (ex Model::External)
+  class Show < Create
+    extend Model::BuildMethods # FIXME: how do we communicate that and prevent the include from Model[] ?
+    self.| Model( Song, :update ), before: "operation.new"
+  end
+
+  it { Show.({id: 1})["model"].inspect.must_equal %{#<struct ModelTest::Song id=1>} }
+
+
+  # TODO: with builder!
+
+  #---
+  # provide your own object ModelBuilder that includes BuilderMethods.
+  # this tests that BuildMethods is interchangable and acts as an example how to  decouple
+  # the model building from the operation.
+  class Index < Trailblazer::Operation
+    # DISCUSS: help user to do this kind of behavior?
+    # model Song, :find # ModelBuilder can read this via skills that we pass to it.
+    self["model.class"] = Song
+    self["model.action"] = :find
+
+    # this is to be able to use BuildModel.
+    class ModelBuilder
+      include Trailblazer::Operation::Model::BuildMethods # #instantiate_model and so on.
+      alias_method :call, :model!
+
+      def initialize(skills); @delegator = skills  end
+
+      extend Uber::Delegates
+      delegates :@delegator, :[]
+    end
+
+    self.> ->(options) { options["model"] = ModelBuilder.new(options).(options["params"]) }, after: "operation.new"
+  end
+
+  it { Index.(id: 1)["model"].inspect.must_equal %{#<struct ModelTest::Song id=1>} }
+end

data/test/operation/params_test.rb

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

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class PersistTest < Minitest::Spec
+  Song = Struct.new(:title, :saved) do
+    def save; title=="Fail!" ? false : self.saved = true; end
+  end
+
+  class Create < Trailblazer::Operation
+    extend Contract::DSL
+    contract do
+      property :title
+    end
+
+    self.| Model( Song, :new )
+    self.| Contract::Build()
+    self.| Contract::Validate()
+    self.< ->(options) { options["1. fail"] = "Validate" }
+    self.| Persist()
+    self.< ->(options) { options["2. fail"] = "Persist" }
+  end
+
+  it { Create.(title: "In Recital")["model"].title.must_equal "In Recital" }
+  it { Create.(title: "In Recital")["model"].saved.must_equal true }
+  # failure
+  it do
+    result = Create.(title: "Fail!")
+    result["model"].saved.must_equal nil
+    result["model"].title.must_equal "Fail!"
+    result["2. fail"].must_equal "Persist"
+    result.success?.must_equal false
+  end
+
+  #---
+  #- inheritance
+  class Update < Create
+  end
+
+  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&validate.params.extract,&contract.validate,<PersistTest::Update:17,&persist.save,<PersistTest::Update:19]} }
+
+  #---
+  it do
+    skip "show how save! could be applied and how we could rescue and deviate to left track"
+  end
+end

data/test/operation/pipedream_test.rb

@@ -0,0 +1,59 @@
+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".
+
+
+
+    self.|         Model[ Song, :new ]      # model!)
+    self.| Policy::Guard[ ->(options){ options["current_user"] == ::Module } ]
+    self.|      Contract[ MyContract]
+    self.|        Policy[ Auth, :user_and_model?]
+    self.<      Contract[ MyContract]
+
+    # self.| :model
+    # self.| :guard
+    # self.| :contract
+
+
+    # ok Model[Song, :new]      # model!)
+    # ok Policy::Guard[ ->(options){ options["current_user"] == ::Module } ]
+    # ok Contract[MyContract]
+    # fail Contract[MyContract]
+    # self.|> "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

@@ -0,0 +1,104 @@
+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?
+    self.& MyValidate, before: Call #replace: Contract::ValidLegacySwitch
+    #
+    MyAfterSave = ->(input, options) { input["after_save"] = true }
+    self.> MyAfterSave, after: MyValidate
+
+    ValidateFailureLogger = ->(input, options) { input["validate fail"] = true }
+    self.< ValidateFailureLogger, after: MyValidate
+
+    self.> ->(input, options) { input.process(options["params"]) }, replace: Call, name: "my.params"
+
+    include Model
+
+    LogBreach = ->(input, options) { input.log_breach! }
+
+    self.< 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