trailblazer 2.0.7 → 2.1.0

data/test/operation/model_test.rb

@@ -1,60 +0,0 @@
-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
-    step Model Song, :new
-  end
-
-  # :new new.
-  it { Create.({})["model"].inspect.must_equal %{#<struct ModelTest::Song id=nil>} }
-
-  class Update < Create
-    step Model( Song, :find ), override: true
-  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]} }
-
-  #---
-  # :find_by, exceptionless.
-  class Find < Trailblazer::Operation
-    step Model Song, :find_by
-    step :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
-
-  # #---
-  # # 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[] ?
-  #   step Model( Song, :update ), before: "operation.new"
-  # end
-
-  # it { Show.({id: 1})["model"].inspect.must_equal %{#<struct ModelTest::Song id=1>} }
-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/persist_test.rb

@@ -1,44 +0,0 @@
-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
-
-    step Model( Song, :new )
-    step Contract::Build()
-    step Contract::Validate()
-    failure ->(options) { options["1. fail"] = "Validate" }
-    step Contract::Persist()
-    failure ->(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,>contract.default.validate,<persist_test.rb:17,>persist.save,<persist_test.rb: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

@@ -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/pundit_test.rb

@@ -1,104 +0,0 @@
-require "test_helper"
-require "trailblazer/operation/policy"
-
-class PolicyTest < Minitest::Spec
-  Song = Struct.new(:id) do
-    def self.find(id); new(id) end
-  end
-
-  class Auth
-    def initialize(user, model); @user, @model = user, model 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
-
-  #---
-  # Instance-level: Only policy, no model
-  class Create < Trailblazer::Operation
-    step Policy::Pundit( Auth, :only_user? )
-    step :process
-
-    def process(*)
-      self["process"] = true
-    end
-  end
-
-  # successful.
-  it do
-    result = Create.({}, "current_user" => Module)
-    result["process"].must_equal true
-    #- result object, policy
-    result["result.policy.default"].success?.must_equal true
-    result["result.policy.default"]["message"].must_equal nil
-    # result[:valid].must_equal nil
-    result["policy.default"].inspect.must_equal %{<Auth: user:Module, model:nil>}
-  end
-  # breach.
-  it do
-    result = Create.({}, "current_user" => nil)
-    result["process"].must_equal nil
-    #- result object, policy
-    result["result.policy.default"].success?.must_equal false
-    result["result.policy.default"]["message"].must_equal "Breach"
-  end
-  # inject different policy.Condition  it { Create.({}, "current_user" => Object, "policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_object?))["process"].must_equal true }
-  it { Create.({}, "current_user" => Module, "policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_object?))["process"].must_equal nil }
-
-
-  #---
-  # inheritance, adding Model
-  class Show < Create
-    step Model( Song, :new ), before: "policy.default.eval"
-  end
-
-  it { Show["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>policy.default.eval,>process]} }
-
-  # invalid because user AND model.
-  it do
-    result = Show.({}, "current_user" => Module)
-    result["process"].must_equal nil
-    result["model"].inspect.must_equal %{#<struct PolicyTest::Song id=nil>}
-    # result["policy"].inspect.must_equal %{#<struct PolicyTest::Song id=nil>}
-  end
-
-  # valid because new policy.
-  it do
-    # puts Show["pipetree"].inspect
-    result = Show.({}, "current_user" => Module, "policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_and_model?))
-    result["process"].must_equal true
-    result["model"].inspect.must_equal %{#<struct PolicyTest::Song id=nil>}
-    result["policy.default"].inspect.must_equal %{<Auth: user:Module, model:#<struct PolicyTest::Song id=nil>>}
-  end
-
-  ##--
-  # TOOOODOOO: Policy and Model before Build ("External" or almost Resolver)
-  class Edit < Trailblazer::Operation
-    step Model Song, :find
-    step Policy::Pundit( Auth, :user_and_model? )
-    step :process
-
-    def process(*); self["process"] = true end
-  end
-
-  # successful.
-  it do
-    result = Edit.({ id: 1 }, "current_user" => Module)
-    result["process"].must_equal true
-    result["model"].inspect.must_equal %{#<struct PolicyTest::Song id=1>}
-    result["result.policy.default"].success?.must_equal true
-    result["result.policy.default"]["message"].must_equal nil
-    # result[:valid].must_equal nil
-    result["policy.default"].inspect.must_equal %{<Auth: user:Module, model:#<struct PolicyTest::Song id=1>>}
-  end
-
-  # breach.
-  it do
-    result = Edit.({ id: 4 }, "current_user" => nil)
-    result["model"].inspect.must_equal %{#<struct PolicyTest::Song id=4>}
-    result["process"].must_equal nil
-    result["result.policy.default"].success?.must_equal false
-    result["result.policy.default"]["message"].must_equal "Breach"
-  end
-end

data/test/operation/representer_test.rb

@@ -1,254 +0,0 @@
-require "test_helper"
-require "representable/json"
-
-class RepresenterTest < MiniTest::Spec
-  Album  = Struct.new(:title, :artist)
-  Artist = Struct.new(:name)
-
-  class Create < Trailblazer::Operation
-    include Contract::Explicit
-    include Representer
-    include Representer::InferFromContract
-    attr_reader :model # FIXME: all we want is #model.
-
-    contract do
-      property :title
-      validates :title, presence: true
-      property :artist, populate_if_empty: Artist do
-        property :name
-        validates :name, presence: true
-      end
-    end
-
-    def call(params)
-      self["model"] = Album.new # NO artist!!!
-      validate(params[:album], model: self["model"])
-      self
-    end
-  end
-
-
-  # Infers representer from contract, no customization.
-  class Show < Create
-    def call(params)
-      self["model"] = Album.new("After The War", Artist.new("Gary Moore"))
-      self
-    end
-  end
-
-
-  # Infers representer, adds hypermedia.
-  require "roar/json/hal"
-  class HypermediaCreate < Create
-    representer do
-      include Roar::JSON::HAL
-
-      link(:self) { "//album/#{represented.title}" }
-    end
-  end
-
-  class HypermediaShow < HypermediaCreate
-    def call(params)
-      self["model"] = Album.new("After The War", Artist.new("Gary Moore"))
-      self
-    end
-  end
-
-
-  # rendering
-  # generic contract -> representer
-  it { Show.().to_json.must_equal %{{"title":"After The War","artist":{"name":"Gary Moore"}}} }
-
-  # contract -> representer with hypermedia
-  it do
-    HypermediaShow.().to_json.must_equal %{{"title":"After The War","artist":{"name":"Gary Moore"},"_links":{"self":{"href":"//album/After The War"}}}}
-  end
-
-
-  # parsing
-  it do
-    op = Create.(album: %{{"title":"Run For Cover","artist":{"name":"Gary Moore"}}})
-    op.contract.title.must_equal "Run For Cover"
-    op.contract.artist.name.must_equal "Gary Moore"
-  end
-
-  it do
-    op = HypermediaCreate.(album: %{{"title":"After The War","artist":{"name":"Gary Moore"},"_links":{"self":{"href":"//album/After The War"}}}})
-    op.contract.title.must_equal "After The War"
-    op.contract.artist.name.must_equal "Gary Moore"
-  end
-
-
-
-
-
-  # explicit representer set with ::representer_class=.
-  require "roar/decorator"
-  class JsonApiCreate < Trailblazer::Operation
-    include Contract::Explicit
-    include Representer
-    attr_reader :model
-
-    contract do # we still need contract as the representer writes to the contract twin.
-      property :title
-    end
-
-    class AlbumRepresenter < Roar::Decorator
-      include Roar::JSON
-      property :title
-    end
-
-    # FIXME: this won't inherit, of course.
-    # self["representer.class"] = AlbumRepresenter
-    representer AlbumRepresenter
-
-    def call(params)
-      self["model"] = Album.new # NO artist!!!
-      validate(params[:album], model: self["model"])
-      self
-    end
-  end
-
-  class JsonApiShow < JsonApiCreate
-    def call(params)
-      self["model"] = Album.new("After The War", Artist.new("Gary Moore"))
-      self
-    end
-  end
-
-  # render.
-  it do
-    JsonApiShow.().to_json.must_equal %{{"title":"After The War"}}
-  end
-
-  # parse.
-  it do
-    JsonApiCreate.(album: %{{"title":"Run For Cover"}}).contract.title.must_equal "Run For Cover"
-  end
-end
-
-class InternalRepresenterAPITest < MiniTest::Spec
-  Song = Struct.new(:id)
-
-  describe "#represented" do
-    class Show < Trailblazer::Operation
-      include Contract::Explicit
-      include Representer, Model
-      model Song, :create
-
-      representer do
-        property :class
-      end
-
-      def call(*)
-        self
-      end
-
-      def model # FIXME.
-        self["model"]
-      end
-    end
-
-    it "uses #model as represented, per default" do
-      Show.({}).to_json.must_equal '{"class":"InternalRepresenterAPITest::Song"}'
-    end
-
-    class ShowContract < Show
-      def represented
-        "Object"
-      end
-    end
-
-    it "can be overriden to use the contract" do
-      ShowContract.({}).to_json.must_equal %{{"class":"String"}}
-    end
-  end
-
-  describe "#to_json" do
-    class OptionsShow < Trailblazer::Operation
-      include Representer
-
-      representer do
-        property :class
-        property :id
-      end
-
-      def to_json(*)
-        super(self["params"])
-      end
-
-      include Model::Builder
-      def model!(*)
-        Song.new(1)
-      end
-    end
-
-    it "allows to pass options to #to_json" do
-      OptionsShow.(include: [:id]).to_json.must_equal %{{"id":1}}
-    end
-  end
-end
-
-class DifferentParseAndRenderingRepresenterTest < MiniTest::Spec
-  Album = Struct.new(:title)
-
-  # rendering
-  class Create < Trailblazer::Operation
-    include Contract::Explicit
-    extend Representer::DSL
-    include Representer::Rendering # no Deserializer::Hash here or anything.
-
-    contract do
-      property :title
-    end
-
-    representer do
-      property :title, as: :Title
-    end
-
-    def call(params)
-      self["model"] = Album.new
-      validate(params) do
-        contract.sync
-      end
-      self
-    end
-  end
-
-  it do
-    Create.(title: "The Kids").to_json.must_equal %{{"Title":"The Kids"}}
-  end
-
-  # parsing
-  class Update < Trailblazer::Operation
-    include Contract::Explicit
-    extend Representer::DSL
-    include Representer::Deserializer::Hash # no Rendering.
-
-    representer do
-      property :title, as: :Title
-    end
-
-    contract do
-      property :title
-    end
-
-    def call(params)
-      self["model"] = Album.new
-
-      validate(params) do
-        contract.sync
-      end
-
-      self
-    end
-
-    def to_json(*)
-      %{{"title": "#{self["model"].title}"}}
-    end
-  end
-
-  it do
-    Update.("Title" => "The Kids").to_json.must_equal %{{"title": "The Kids"}}
-  end
-end