trailblazer 1.1.2 → 2.0.0.beta1

data/test/docs/dry_test.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+require "dry/container"
+
+class DryContainerTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+
+  class MyContract < Reform::Form
+    property :title
+    validates :title, length: 2..33
+  end
+
+  my_container = Dry::Container.new
+  my_container.register("contract.default.class", MyContract)
+  # my_container.namespace("contract") do
+  #   register("create") { Array }
+  # end
+
+  #---
+  #- dependency injection
+  #- with Dry-container
+  class Create < Trailblazer::Operation
+    self.| Model( Song, :new )
+    self.| Contract::Build()
+    self.| Contract::Validate()
+    self.| Persist( method: :sync )
+  end
+  #:key end
+
+  it { Create.({ title: "A" }, {}, my_container).inspect("model").must_equal %{<Result:false [#<struct DryContainerTest::Song id=nil, title=nil>] >} }
+  it { Create.({ title: "Anthony's Song" }, {}, my_container).inspect("model").must_equal %{<Result:true [#<struct DryContainerTest::Song id=nil, title="Anthony's Song">] >} }
+end

data/test/docs/guard_test.rb

@@ -0,0 +1,143 @@
+require "test_helper"
+
+#--
+# with proc
+class DocsGuardProcTest < Minitest::Spec
+  #:proc
+  class Create < Trailblazer::Operation
+    step Policy::Guard( ->(options) { options["params"][:pass] } )
+    step :process
+    #~pipeonly
+
+    def process(*)
+      self["x"] = true
+    end
+    #~pipeonly end
+  end
+  #:proc end
+
+  it { Create.(pass: false)["x"].must_equal nil }
+  it { Create.(pass: true)["x"].must_equal true }
+
+  #- result object, guard
+  it { Create.(pass: true)["result.policy.default"].success?.must_equal true }
+  it { Create.(pass: false)["result.policy.default"].success?.must_equal false }
+
+
+
+
+   #---
+  #- Guard inheritance
+  class New < Create
+  end
+
+  it { New["pipetree"].inspect.must_equal %{[>>operation.new,&policy.default.eval,>process]} }
+end
+
+#---
+# with Callable
+class DocsGuardTest < Minitest::Spec
+  #:callable
+  class MyGuard
+    include Uber::Callable
+
+    def call(options)
+      options["params"][:pass]
+    end
+  end
+  #:callable end
+
+  #:callable-op
+  class Create < Trailblazer::Operation
+    step Policy::Guard( MyGuard.new )
+    step :process
+    #~pipe-only
+    def process(*); self[:x] = true; end
+    #~pipe-only end
+  end
+  #:callable-op end
+
+  it { Create.(pass: false)[:x].must_equal nil }
+  it { Create.(pass: true)[:x].must_equal true }
+end
+
+#---
+# with method
+# class DocsGuardMethodTest < Minitest::Spec
+#   #:method
+#   class Create < Trailblazer::Operation
+#     step Policy::Guard[ : ]
+#     step :process
+#     #~pipe-only
+#     def process(*); self[:x] = true; end
+#     #~pipe-only end
+#   end
+#   #:method end
+
+#   it { Create.(pass: false)[:x].must_equal nil }
+#   it { Create.(pass: true)[:x].must_equal true }
+# end
+
+#---
+# with name:
+class DocsGuardNamedTest < Minitest::Spec
+  #:name
+  class Create < Trailblazer::Operation
+    step Policy::Guard( ->(options) { options["current_user"] }, name: :user )
+    # ...
+  end
+  #:name end
+
+  it { Create.()["result.policy.user"].success?.must_equal false }
+  it { Create.({}, "current_user" => Module)["result.policy.user"].success?.must_equal true }
+
+  it {
+  #:name-result
+  result = Create.({}, "current_user" => true)
+  result["result.policy.user"].success? #=> true
+  #:name-result end
+  }
+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
+
+#---
+# dependency injection
+class DocsGuardInjectionTest < Minitest::Spec
+  #:di-op
+  class Create < Trailblazer::Operation
+    step Policy::Guard( ->(options) { options["current_user"] == Module } )
+  end
+  #:di-op end
+
+  it { Create.({}, "current_user" => Module).inspect("").must_equal %{<Result:true [nil] >} }
+  it {
+    result =
+  #:di-call
+  Create.({},
+    "current_user"        => Module,
+    "policy.default.eval" => Trailblazer::Operation::Policy::Guard.build(->(options) { false })
+  )
+  #:di-call end
+    result.inspect("").must_equal %{<Result:false [nil] >} }
+end
+
+
+# TODO:
+#policy.default

data/test/docs/nested_test.rb

@@ -0,0 +1,117 @@
+require "test_helper"
+
+class DocsNestedOperationTest < Minitest::Spec
+  Song = Struct.new(:id, :title) do
+    def self.find(id)
+      return new(1, "Bristol") if id == 1
+    end
+  end
+
+  #---
+  #- nested operations
+  #:edit
+  class Edit < Trailblazer::Operation
+    extend Contract::DSL
+
+    contract do
+      property :title
+    end
+
+    step Model( Song, :find )
+    step Contract::Build()
+  end
+  #:edit end
+
+    # step Nested( Edit ) #, "policy.default" => self["policy.create"]
+  #:update
+  class Update < Trailblazer::Operation
+    step Nested( Edit )
+    step Contract::Validate()
+    step Persist( method: :sync )
+  end
+  #:update end
+
+  puts Update["pipetree"].inspect(style: :rows)
+
+  #-
+  # Edit allows grabbing model and contract
+  it do
+  #:edit-call
+  result = Edit.(id: 1)
+
+  result["model"]            #=> #<Song id=1, title=\"Bristol\">
+  result["contract.default"] #=> #<Reform::Form ..>
+  #:edit-call end
+    result.inspect("model").must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Bristol\">] >}
+    result["contract.default"].model.must_equal result["model"]
+  end
+
+  #-
+  # Update also allows grabbing model and contract
+  it do
+  #:update-call
+  result = Update.(id: 1, title: "Call It A Night")
+
+  result["model"]            #=> #<Song id=1 , title=\"Call It A Night\">
+  result["contract.default"] #=> #<Reform::Form ..>
+  #:update-call end
+    result.inspect("model").must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Call It A Night\">] >}
+    result["contract.default"].model.must_equal result["model"]
+  end
+
+  #-
+  # Edit is successful.
+  it do
+    result = Update.({ id: 1, title: "Miami" }, "current_user" => Module)
+    result.inspect("model").must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title="Miami">] >}
+  end
+
+  # Edit fails
+  it do
+    Update.(id: 2).inspect("model").must_equal %{<Result:false [nil] >}
+  end
+
+  #- shared data
+  class B < Trailblazer::Operation
+    self.> ->(options) { options["can.B.see.it?"] = options["this.should.not.be.visible.in.B"] }
+    self.> ->(options) { options["can.B.see.current_user?"] = options["current_user"] }
+    self.> ->(options) { options["can.B.see.A.class.data?"] = options["A.class.data"] }
+  end
+
+  class A < Trailblazer::Operation
+    self["A.class.data"] = true
+
+    self.> ->(options) { options["this.should.not.be.visible.in.B"] = true }
+    step Nested B
+  end
+
+  # mutual data from A doesn't bleed into B.
+  it { A.()["can.B.see.it?"].must_equal nil }
+  it { A.()["this.should.not.be.visible.in.B"].must_equal true }
+  # runtime dependencies are visible in B.
+  it { A.({}, "current_user" => Module)["can.B.see.current_user?"].must_equal Module }
+  # class data from A doesn't bleed into B.
+  it { A.()["can.B.see.A.class.data?"].must_equal nil }
+
+
+  # cr_result = Create.({}, "result" => result)
+  # puts cr_result["model"]
+  # puts cr_result["contract.default"]
+end
+
+class NestedClassLevelTest < Minitest::Spec
+  #:class-level
+  class New < Trailblazer::Operation
+    step ->(options) { options["class"] = true }, before: "operation.new"
+    step ->(options) { options["x"] = true }
+  end
+
+  class Create < Trailblazer::Operation
+    step Nested New
+    step ->(options) { options["y"] = true }
+  end
+  #:class-level end
+
+  it { Create.().inspect("x", "y").must_equal %{<Result:true [true, true] >} }
+  it { Create.(); Create["class"].must_equal nil }
+end

data/test/docs/policy_test.rb

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

data/test/docs/pundit_test.rb

@@ -0,0 +1,109 @@
+require "test_helper"
+
+#:policy
+class MyPolicy
+  def initialize(user, model)
+    @user, @model = user, model
+  end
+
+  def create?
+    @user == Module && @model.id.nil?
+  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.({}, "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
+
+   #---
+  #- Guard inheritance
+  class New < Create
+  end
+
+  it { New["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,&policy.default.eval]} }
+
+  #---
+  # 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

@@ -0,0 +1,268 @@
+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 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 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 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 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 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