trailblazer 2.0.7 → 2.1.0

data/test/docs/policy_test.rb

@@ -1,2 +0,0 @@
-# add anything to result
-# insert any options into constructor

data/test/docs/pundit_test.rb

@@ -1,133 +0,0 @@
-require "test_helper"
-
-  #:policy
-  class MyPolicy
-    def initialize(user, model)
-      @user, @model = user, model
-    end
-
-    def create?
-      @user == Module && @model.id.nil?
-    end
-
-    def new?
-      @user == Class
-    end
-  end
-  #:policy end
-
-#--
-# with policy
-class DocsPunditProcTest < Minitest::Spec
-  Song = Struct.new(:id)
-
-  #:pundit
-  class Create < Trailblazer::Operation
-    step Model( Song, :new )
-    step Policy::Pundit( MyPolicy, :create? )
-    # ...
-  end
-  #:pundit end
-
-  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>policy.default.eval]} }
-  it { Create.({}, "current_user" => Module).inspect("model").must_equal %{<Result:true [#<struct DocsPunditProcTest::Song id=nil>] >} }
-  it { Create.({}                          ).inspect("model").must_equal %{<Result:false [#<struct DocsPunditProcTest::Song id=nil>] >} }
-
-  it do
-  #:pundit-result
-  result = Create.({}, "current_user" => Module)
-  result["result.policy.default"].success? #=> true
-  result["result.policy.default"]["policy"] #=> #<MyPolicy ...>
-  #:pundit-result end
-    result["result.policy.default"].success?.must_equal true
-    result["result.policy.default"]["policy"].is_a?(MyPolicy).must_equal true
-  end
-
-  #---
-  #- override
-  class New < Create
-    step Policy::Pundit( MyPolicy, :new? ), override: true
-  end
-
-  it { New["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>policy.default.eval]} }
-  it { New.({}, "current_user" => Class ).inspect("model").must_equal %{<Result:true [#<struct DocsPunditProcTest::Song id=nil>] >} }
-  it { New.({}, "current_user" => nil ).inspect("model").must_equal %{<Result:false [#<struct DocsPunditProcTest::Song id=nil>] >} }
-
-  #---
-  #- override with :name
-  class Edit < Trailblazer::Operation
-    step Policy::Pundit( MyPolicy, :create?, name: "first" )
-    step Policy::Pundit( MyPolicy, :new?,    name: "second" )
-  end
-
-  class Update < Edit
-    step Policy::Pundit( MyPolicy, :new?, name: "first" ), override: true
-  end
-
-  it { Edit["pipetree"].inspect.must_equal %{[>operation.new,>policy.first.eval,>policy.second.eval]} }
-  it { Edit.({}, "current_user" => Class).inspect("model").must_equal %{<Result:false [nil] >} }
-  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>policy.first.eval,>policy.second.eval]} }
-  it { Update.({}, "current_user" => Class).inspect("model").must_equal %{<Result:true [nil] >} }
-
-  #---
-  # dependency injection
-  class AnotherPolicy < MyPolicy
-    def create?
-      true
-    end
-  end
-
-  it {
-    result =
-  #:di-call
-  Create.({},
-    "current_user"        => Module,
-    "policy.default.eval" => Trailblazer::Operation::Policy::Pundit.build(AnotherPolicy, :create?)
-  )
-  #:di-call end
-    result.inspect("").must_equal %{<Result:true [nil] >} }
-end
-
-#-
-# with name:
-class PunditWithNameTest < Minitest::Spec
-  Song = Struct.new(:id)
-
-  #:name
-  class Create < Trailblazer::Operation
-    step Model( Song, :new )
-    step Policy::Pundit( MyPolicy, :create?, name: "after_model" )
-    # ...
-  end
-  #:name end
-
-  it {
-  #:name-call
-  result = Create.({}, "current_user" => Module)
-  result["result.policy.after_model"].success? #=> true
-  #:name-call end
-    result["result.policy.after_model"].success?.must_equal true }
-end
-
-#---
-# class-level guard
-# class DocsGuardClassLevelTest < Minitest::Spec
-#   #:class-level
-#   class Create < Trailblazer::Operation
-#     step Policy::Guard[ ->(options) { options["current_user"] == Module } ],
-#       before: "operation.new"
-#     #~pipe--only
-#     step ->(options) { options["x"] = true }
-#     #~pipe--only end
-#   end
-#   #:class-level end
-
-#   it { Create.(); Create["result.policy"].must_equal nil }
-#   it { Create.({}, "current_user" => Module)["x"].must_equal true }
-#   it { Create.({}                          )["x"].must_equal nil }
-# end
-
-
-
-# TODO:
-#policy.default

data/test/docs/representer_test.rb

@@ -1,268 +0,0 @@
-require "test_helper"
-require "representable/json"
-
-#---
-# infer
-class DocsRepresenterInferTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-
-  #:infer
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :id
-    end
-
-    step Model( Song, :new )
-    step Contract::Build( constant: MyContract )
-    step Contract::Validate( representer: Representer.infer(MyContract, format: Representable::JSON) )
-    step Contract::Persist( method: :sync )
-  end
-  #:infer end
-
-  let (:json) { MultiJson.dump(id: 1) }
-  it { Create.({}, "document" => json).inspect("model").must_equal %{<Result:true [#<struct DocsRepresenterInferTest::Song id=1, title=nil>] >} }
-end
-
-#---
-# explicit
-class DocsRepresenterExplicitTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-
-  #:explicit-rep
-  class MyRepresenter < Representable::Decorator
-    include Representable::JSON
-    property :id
-  end
-  #:explicit-rep end
-
-  #:explicit-op
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :id
-    end
-
-    step Model( Song, :new )
-    step Contract::Build( constant: MyContract )
-    step Contract::Validate( representer: MyRepresenter ) # :representer
-    step Contract::Persist( method: :sync )
-  end
-  #:explicit-op end
-
-  let (:json) { MultiJson.dump(id: 1) }
-  it { Create.({}, "document" => json).inspect("model").must_equal %{<Result:true [#<struct DocsRepresenterExplicitTest::Song id=1, title=nil>] >} }
-  it do
-  #:explicit-call
-  Create.({}, "document" => '{"id": 1}')
-  #:explicit-call end
-  end
-
-  #- render
-  it do
-  #:render
-  result = Create.({}, "document" => '{"id": 1}')
-  json   = result["representer.default.class"].new(result["model"]).to_json
-  json #=> '{"id":1}'
-  #:render end
-  json.must_equal '{"id":1}'
-  end
-
-  #-
-  # with dependency injection
-  # overriding the JSON representer with an XML one.
-  #:di-rep
-  require "representable/xml"
-
-  class MyXMLRepresenter < Representable::Decorator
-    include Representable::XML
-    property :id
-  end
-  #:di-rep end
-
-  let (:xml) { %{<body><id>1</id></body>} }
-  it do
-  #:di-call
-  result = Create.({},
-    "document" => '<body><id>1</id></body>',
-    "representer.default.class" => MyXMLRepresenter # injection
-  )
-  #:di-call end
-    result.inspect("model").must_equal %{<Result:true [#<struct DocsRepresenterExplicitTest::Song id="1", title=nil>] >}
-  end
-end
-
-#---
-# dependency injection
-class DocsRepresenterDITest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-
-  class MyRepresenter < Representable::Decorator
-    include Representable::JSON
-    property :id
-  end
-
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :id
-    end
-
-    step Model( Song, :new )
-    step Contract::Build( constant: MyContract )
-    step Contract::Validate()
-    step Contract::Persist( method: :sync )
-  end
-
-  let (:json) { MultiJson.dump(id: 1) }
-  it { Create.({}, "document" => json,
-    "representer.default.class" => MyRepresenter).inspect("model").must_equal %{<Result:true [#<struct DocsRepresenterDITest::Song id=1, title=nil>] >} }
-end
-
-#---
-# inline
-class DocsRepresenterInlineTest < Minitest::Spec
-  Song = Struct.new(:id, :title)
-
-  #:inline
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :id
-    end
-
-    extend Representer::DSL
-
-    representer do
-      property :id
-    end
-
-    step Model( Song, :new )
-    step Contract::Build( constant: MyContract )
-    step Contract::Validate( representer: self["representer.default.class"] )
-    step Contract::Persist( method: :sync )
-  end
-  #:inline end
-
-  let (:json) { MultiJson.dump(id: 1) }
-  it { Create.({}, "document" => json).inspect("model").must_equal %{<Result:true [#<struct DocsRepresenterInlineTest::Song id=1, title=nil>] >} }
-end
-
-#---
-# rendering
-class DocsRepresenterManualRenderTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find(id)
-      new(id)
-    end
-  end
-
-  class Show < Trailblazer::Operation
-    extend Representer::DSL
-    representer do
-      property :id
-    end
-
-    step Model( Song, :find )
-  end
-
-  it do
-    result =Show.({ id: 1 })
-    json = result["representer.default.class"].new(result["model"]).to_json
-    json.must_equal %{{"id":1}}
-  end
-end
-
-#---
-# naming
-
-class DocsRepresenterNamingTest < Minitest::Spec
-  MyRepresenter = Object
-
-  #:naming
-  class Create < Trailblazer::Operation
-    extend Representer::DSL
-    representer MyRepresenter
-  end
-
-  Create["representer.default.class"] #=> MyRepresenter
-  #:naming end
-  it { Create["representer.default.class"].must_be_kind_of MyRepresenter }
-end
-
-#---
-# rendering
-require "roar/json/hal"
-
-class DocsRepresenterFullExampleTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def initialize(*)
-      self.id = 1
-    end
-  end
-
-  #:errors-rep
-  class ErrorsRepresenter < Representable::Decorator
-    include Representable::JSON
-    collection :errors
-  end
-  #:errors-rep end
-
-  #:full
-  class Create < Trailblazer::Operation
-    extend Contract::DSL
-    extend Representer::DSL
-
-    contract do
-      property :title
-      validates :title, presence: true
-    end
-
-    representer :parse do
-      property :title
-    end
-
-    representer :render do
-      include Roar::JSON::HAL
-
-      property :id
-      property :title
-      link(:self) { "/songs/#{represented.id}" }
-    end
-
-    representer :errors, ErrorsRepresenter # explicit reference.
-
-    step Model( Song, :new )
-    step Contract::Build()
-    step Contract::Validate( representer: self["representer.parse.class"] )
-    step Contract::Persist( method: :sync )
-  end
-  #:full end
-
-  it do
-    result =Create.({}, "document" => '{"title": "Tested"}')
-
-    json = result["representer.render.class"].new(result["model"]).to_json
-
-    json.must_equal %{{"id":1,"title":"Tested","_links":{"self":{"href":"/songs/1"}}}}
-
-
-  #:full-call
-  def create
-    result = Create.(params, "document" => request.body.read)
-
-    if result.success?
-      result["representer.render.class"].new(result["model"]).to_json
-    else
-      result["representer.errors.class"].new(result["result.contract.default"]).to_json
-    end
-  end
-  #:full-call end
-  end
-
-  it do
-    result =Create.({}, "document" => '{"title": ""}')
-
-    if result.failure?
-       json = result["representer.errors.class"].new(result["result.contract.default"]).to_json
-    end
-
-    json.must_equal %{{"errors":[["title","can't be blank"]]}}
-  end
-end

data/test/docs/rescue_test.rb

@@ -1,154 +0,0 @@
-require "test_helper"
-
-class NestedRescueTest < Minitest::Spec
-  #---
-  # nested raise (i hope people won't use this but it works)
-  A = Class.new(RuntimeError)
-  Y = Class.new(RuntimeError)
-
-  class NestedInsanity < Trailblazer::Operation
-    step Rescue {
-      step ->(options) { options["a"] = true }
-      step Rescue {
-        step ->(options) { options["y"] = true }
-        success ->(options) { raise Y if options["raise-y"] }
-        step ->(options) { options["z"] = true }
-      }
-      step ->(options) { options["b"] = true }
-      success ->(options) { raise A if options["raise-a"] }
-      step ->(options) { options["c"] = true }
-      failure ->(options) { options["inner-err"] = true }
-    }
-    step ->(options) { options["e"] = true }
-    failure ->(options) { options["outer-err"] = true }
-  end
-
-  it { NestedInsanity["pipetree"].inspect.must_equal %{[>operation.new,>Rescue:10,>rescue_test.rb:22,<rescue_test.rb:23]} }
-  it { NestedInsanity.({}).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
-  it { NestedInsanity.({}, "raise-y" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, nil, nil, nil, nil, true, true] >} }
-  it { NestedInsanity.({}, "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
-
-  #-
-  # inheritance
-  class UbernestedInsanity < NestedInsanity
-  end
-
-  it { UbernestedInsanity.({}).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
-  it { UbernestedInsanity.({}, "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
-end
-
-class RescueTest < Minitest::Spec
-  RecordNotFound = Class.new(RuntimeError)
-
-  Song = Struct.new(:id, :title) do
-    def self.find(id)
-      raise if id == "RuntimeError!"
-      id.nil? ? raise(RecordNotFound) : new(id)
-    end
-
-    def lock!
-      true
-    end
-  end
-
-  #:simple
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :title
-    end
-
-    step Rescue {
-      step Model(Song, :find)
-      step Contract::Build( constant: MyContract )
-    }
-    step Contract::Validate()
-    step Contract::Persist( method: :sync )
-  end
-  #:simple end
-
-  it { Create.( id: 1, title: "Prodigal Son" )["contract.default"].model.inspect.must_equal %{#<struct RescueTest::Song id=1, title="Prodigal Son">} }
-  it { Create.( id: nil ).inspect("model").must_equal %{<Result:false [nil] >} }
-
-  #-
-  # Rescue ExceptionClass, handler: ->(*) { }
-  class WithExceptionNameTest < Minitest::Spec
-  #
-  class MyContract < Reform::Form
-    property :title
-  end
-  #:name
-  class Create < Trailblazer::Operation
-    step Rescue( RecordNotFound, KeyError, handler: :rollback! ) {
-      step Model( Song, :find )
-      step Contract::Build( constant: MyContract )
-    }
-    step Contract::Validate()
-    step Contract::Persist( method: :sync )
-
-    def rollback!(exception, options)
-      options["x"] = exception.class
-    end
-  end
-  #:name end
-
-    it { Create.( id: 1, title: "Prodigal Son" )["contract.default"].model.inspect.must_equal %{#<struct RescueTest::Song id=1, title="Prodigal Son">} }
-    it { Create.( id: 1, title: "Prodigal Son" ).inspect("x").must_equal %{<Result:true [nil] >} }
-    it { Create.( id: nil ).inspect("model", "x").must_equal %{<Result:false [nil, RescueTest::RecordNotFound] >} }
-    it { assert_raises(RuntimeError) { Create.( id: "RuntimeError!" ) } }
-  end
-
-
-  #-
-  # cdennl use-case
-  class CdennlRescueAndTransactionTest < Minitest::Spec
-    module Sequel
-      cattr_accessor :result
-
-      def self.transaction
-        yield.tap do |res|
-          self.result = res
-        end
-      end
-    end
-
-  #:example
-  class Create < Trailblazer::Operation
-    class MyContract < Reform::Form
-      property :title
-    end
-
-    step Rescue( RecordNotFound, handler: :rollback! ) {
-      step Wrap ->(*, &block) { Sequel.transaction do block.call end } {
-        step Model( Song, :find )
-        step ->(options) { options["model"].lock! } # lock the model.
-        step Contract::Build( constant: MyContract )
-        step Contract::Validate( )
-        step Contract::Persist( method: :sync )
-      }
-    }
-    failure :error! # handle all kinds of errors.
-
-    def rollback!(exception, options)
-      #~ex
-      options["x"] = exception.class
-      #~ex end
-    end
-
-    def error!(options)
-      #~ex
-      options["err"] = true
-      #~ex end
-    end
-  end
-  #:example end
-
-    it { Create.( id: 1, title: "Pie" ).inspect("model", "x", "err").must_equal %{<Result:true [#<struct RescueTest::Song id=1, title=\"Pie\">, nil, nil] >} }
-    # raise exceptions in Model:
-    it { Create.( id: nil ).inspect("model", "x").must_equal %{<Result:false [nil, RescueTest::RecordNotFound] >} }
-    it { assert_raises(RuntimeError) { Create.( id: "RuntimeError!" ) } }
-    it do
-      Create.( id: 1, title: "Pie" )
-      Sequel.result.first.must_equal Pipetree::Railway::Right
-    end
-  end
-end