trailblazer 1.1.1 → 2.1.0

data/test/operation_test.rb

@@ -1,275 +0,0 @@
-require "test_helper"
-
-module Inspect
-  def inspect
-    "<#{self.class.to_s.split("::").last} @model=#{@model}>"
-  end
-  alias_method :to_s, :inspect
-end
-
-class OperationSetupParamsTest < MiniTest::Spec
-  class OperationSetupParam < Trailblazer::Operation
-    def process(params)
-      @model = params
-    end
-
-    def setup_params!(params)
-      params.merge!(garrett: "Rocks!")
-    end
-
-    include Inspect
-  end
-
-  # allows you changing params in #setup_params!.
-  it { OperationSetupParam.run({valid: true}).to_s.must_equal "[true, <OperationSetupParam @model={:valid=>true, :garrett=>\"Rocks!\"}>]" }
-end
-
-class OperationParamsTest < MiniTest::Spec
-  class Operation < Trailblazer::Operation
-    def process(params)
-      @model = "#{params} and #{@params==params}"
-    end
-
-    def params!(params)
-      { params: params }
-    end
-  end
-
-  # allows you returning new params in #params!.
-  it { Operation.({valid: true}).model.to_s.must_equal "{:params=>{:valid=>true}} and true" }
-end
-
-# Operation#model.
-class OperationModelTest < MiniTest::Spec
-  class Operation < Trailblazer::Operation
-    def process(params)
-    end
-
-    def model!(params)
-      params
-    end
-  end
-
-  # #model.
-  it { Operation.(Object).model.must_equal Object }
-end
-
-# Operation#model=.
-class OperationModelWriterTest < MiniTest::Spec
-  class Operation < Trailblazer::Operation
-    def process(params)
-      self.model = "#{params}"
-    end
-  end
-
-  it { Operation.("I can set @model via a private setter").model.to_s.must_equal "I can set @model via a private setter" }
-end
-
-class OperationRunTest < MiniTest::Spec
-  class Operation < Trailblazer::Operation
-    # allow providing your own contract.
-    self.contract_class = class Contract
-      def initialize(*)
-      end
-      def validate(params)
-        return true if params == "yes, true"
-        false
-      end
-
-      def errors
-        Struct.new(:to_s).new("Op just calls #to_s on Errors!")
-      end
-      self
-    end
-
-    def process(params)
-      model = Object
-      validate(params, model)
-    end
-
-    include Inspect
-  end
-
-  # contract is inferred from self::contract_class.
-  # ::run returns result set when run without block.
-  it { Operation.run("not true").to_s.must_equal %{[false, <Operation @model=>]} }
-  it { Operation.run("yes, true").to_s.must_equal %{[true, <Operation @model=>]} }
-
-  # ::call raises exception when invalid.
-  it do
-    exception = assert_raises(Trailblazer::Operation::InvalidContract) { Operation.("not true") }
-    exception.message.must_equal "Op just calls #to_s on Errors!"
-  end
-
-  # return operation when ::call
-  it { Operation.("yes, true").to_s.must_equal %{<Operation @model=>} }
-  # #[] is alias for .()
-  it { Operation["yes, true"].to_s.must_equal %{<Operation @model=>} }
-
-
-  # ::run with block returns operation.
-  # valid executes block.
-  it "block" do
-    outcome = nil
-    res = Operation.run("yes, true") do
-      outcome = "true"
-    end
-
-    outcome.must_equal "true" # block was executed.
-    res.to_s.must_equal %{<Operation @model=>}
-  end
-
-  # invalid doesn't execute block.
-  it "block, invalid" do
-    outcome = nil
-    res = Operation.run("no, not true, false") do
-      outcome = "true"
-    end
-
-    outcome.must_equal nil # block was _not_ executed.
-    res.to_s.must_equal %{<Operation @model=>}
-  end
-
-  # block yields operation
-  it do
-    outcome = nil
-    res = Operation.run("yes, true") do |op|
-      outcome = op
-    end
-
-    outcome.to_s.must_equal %{<Operation @model=>} # block was executed.
-    res.to_s.must_equal %{<Operation @model=>}
-  end
-
-  # # Operation#contract returns @contract
-  it { Operation.("yes, true").contract.class.to_s.must_equal "OperationRunTest::Operation::Contract" }
-
-
-
-
-  describe "::present" do
-    class NoContractOp < Trailblazer::Operation
-      self.contract_class = nil
-
-      def model!(*)
-        Object
-      end
-    end
-
-    # the operation and model are available, but no contract.
-    it { NoContractOp.present({}).model.must_equal Object }
-    # no contract is built.
-    it { assert_raises(NoMethodError) { NoContractOp.present({}).contract } }
-    it { assert_raises(NoMethodError) { NoContractOp.run({}) } }
-  end
-end
-
-
-class OperationTest < MiniTest::Spec
-  # test #invalid!
-  class OperationWithoutValidateCall < Trailblazer::Operation
-    def process(params)
-      params || invalid!(params)
-    end
-
-    include Inspect
-  end
-
-  # ::run
-  it { OperationWithoutValidateCall.run(true).to_s.must_equal %{[true, <OperationWithoutValidateCall @model=>]} }
-  # invalid.
-  it { OperationWithoutValidateCall.run(false).to_s.must_equal %{[false, <OperationWithoutValidateCall @model=>]} }
-
-
-  # #validate yields contract when valid
-  class OperationWithValidateBlock < Trailblazer::Operation
-    self.contract_class = class Contract
-      def initialize(*)
-      end
-
-      def validate(params)
-        params
-      end
-      self
-    end
-
-    def process(params)
-      validate(params, Object.new) do |c|
-        @secret_contract = c.class
-      end
-    end
-
-    attr_reader :secret_contract
-  end
-
-  it { OperationWithValidateBlock.run(false).last.secret_contract.must_equal nil }
-  it { OperationWithValidateBlock.(true).secret_contract.must_equal OperationWithValidateBlock::Contract }
-
-
-  # test validate wit if/else
-  class OperationWithValidateAndIf < Trailblazer::Operation
-    self.contract_class = class Contract
-      def initialize(*)
-      end
-
-      def validate(params)
-        params
-      end
-      self
-    end
-
-    def process(params)
-      if validate(params, Object.new)
-        @secret_contract = contract.class
-      else
-        @secret_contract = "so wrong!"
-      end
-    end
-
-    attr_reader :secret_contract
-  end
-
-  it { OperationWithValidateAndIf.run(false).last.secret_contract.must_equal "so wrong!" }
-  it { OperationWithValidateAndIf.(true).secret_contract.must_equal OperationWithValidateAndIf::Contract }
-
-
-
-  # ::present only runs #setup! which runs #model!.
-  class ContractOnlyOperation < Trailblazer::Operation
-    self.contract_class = class Contract
-      def initialize(model)
-        @_model = model
-      end
-      attr_reader :_model
-      self
-    end
-
-    def model!(params)
-      Object
-    end
-
-    def process(params)
-      raise "This is not run!"
-    end
-  end
-
-  it { ContractOnlyOperation.present({}).contract._model.must_equal Object }
-end
-
-
-class OperationErrorsTest < MiniTest::Spec
-  class Operation < Trailblazer::Operation
-    contract do
-      property :title, validates: {presence: true}
-    end
-
-    def process(params)
-      validate(params, OpenStruct.new) {}
-    end
-  end
-
-  it do
-    res, op = Operation.run({})
-    op.errors.to_s.must_equal "{:title=>[\"can't be blank\"]}"
-  end
-end

data/test/representer_test.rb

@@ -1,238 +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
-    require "trailblazer/operation/representer"
-    include Representer
-
-    contract do
-      property :title
-      validates :title, presence: true
-      property :artist, populate_if_empty: Artist do
-        property :name
-        validates :name, presence: true
-      end
-    end
-
-    def process(params)
-      @model = Album.new # NO artist!!!
-      validate(params[:album], @model)
-    end
-  end
-
-
-  # Infers representer from contract, no customization.
-  class Show < Create
-    def process(params)
-      @model = Album.new("After The War", Artist.new("Gary Moore"))
-      @contract = @model
-    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 process(params)
-      @model = Album.new("After The War", Artist.new("Gary Moore"))
-      @contract = @model
-    end
-  end
-
-
-  # rendering
-  # generic contract -> representer
-  it do
-    res, op = Show.run({})
-    op.to_json.must_equal %{{"title":"After The War","artist":{"name":"Gary Moore"}}}
-  end
-
-  # contract -> representer with hypermedia
-  it do
-    res, op = HypermediaShow.run({})
-    op.to_json.must_equal %{{"title":"After The War","artist":{"name":"Gary Moore"},"_links":{"self":{"href":"//album/After The War"}}}}
-  end
-
-
-  # parsing
-  it do
-    res, op = Create.run(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
-    res, op = HypermediaCreate.run(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 Representer
-
-    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
-    self.representer_class = AlbumRepresenter
-
-    def process(params)
-      @model = Album.new # NO artist!!!
-      validate(params[:album], @model)
-    end
-  end
-
-  class JsonApiShow < JsonApiCreate
-    def process(params)
-      @model = Album.new("After The War", Artist.new("Gary Moore"))
-      @contract = @model
-    end
-  end
-
-  # render.
-  it do
-    res, op = JsonApiShow.run({})
-    op.to_json.must_equal %{{"title":"After The War"}}
-  end
-
-  # parse.
-  it do
-    res, op = JsonApiCreate.run(album: %{{"title":"Run For Cover"}})
-    op.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 Representer, Model
-      model Song, :create
-
-      representer do
-        property :class
-      end
-    end
-
-    it "uses #model as represented, per default" do
-      Show.present({}).to_json.must_equal '{"class":"InternalRepresenterAPITest::Song"}'
-    end
-
-    class ShowContract < Show
-      def represented
-        contract
-      end
-    end
-
-    it "can be overriden to use the contract" do
-      ShowContract.present({}).to_json.must_equal %{{"class":"#{ShowContract.contract_class}"}}
-    end
-  end
-
-  describe "#to_json" do
-    class OptionsShow < Trailblazer::Operation
-      include Representer
-
-      representer do
-        property :class
-        property :id
-      end
-
-      def to_json(*)
-        super(@params)
-      end
-
-      def model!(params)
-        Song.new(1)
-      end
-    end
-
-    it "allows to pass options to #to_json" do
-      OptionsShow.present(include: [:id]).to_json.must_equal '{"id":1}'
-    end
-  end
-end
-
-class DifferentParseAndRenderingRepresenterTest < MiniTest::Spec
-  Album = Struct.new(:title)
-
-  # rendering
-  class Create < Trailblazer::Operation
-    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 process(params)
-      @model = Album.new
-      validate(params) do
-        contract.sync
-      end
-    end
-  end
-
-  it do
-    Create.(title: "The Kids").to_json.must_equal %{{"Title":"The Kids"}}
-  end
-
-  # parsing
-  class Update < Trailblazer::Operation
-    extend Representer::DSL
-    include Representer::Deserializer::Hash # no Rendering.
-
-    representer do
-      property :title, as: :Title
-    end
-
-    contract do
-      property :title
-    end
-
-
-    def process(params)
-      @model = Album.new
-
-      validate(params) do
-        contract.sync
-      end
-    end
-
-    def to_json(*)
-      %{{"title": "#{model.title}"}}
-    end
-  end
-
-  it do
-    Update.("Title" => "The Kids").to_json.must_equal %{{"title": "The Kids"}}
-  end
-end

data/test/rollback_test.rb

@@ -1,47 +0,0 @@
-require "test_helper"
-
-# TODO: rollback for composed operations: this is basically implemented already as every operation knows how to rollback.
-# however, this has to be run for composed operations.
-# we can also add Transaction and Lock for real uniqueness validators, etc.
-#
-# i am keen to try integrating https://github.com/collectiveidea/interactor organizers!
-module Trailblazer::Operation::Rollback
-  def run
-    begin
-      super
-    rescue
-      rollback!(@params, $!)
-      [false, self]
-    end
-  end
-end
-
-class RollbackTest < MiniTest::Spec
-  class ExceptionalOperation < Trailblazer::Operation
-    include Rollback
-
-    def process(params)
-      @_params = params
-      raise # something happens.
-    end
-
-    attr_reader :_params, :_rollback_args
-
-    def rollback!(params, exception)
-      @_rollback_args = [params, exception]
-    end
-  end
-
-  module Comparable
-    def ==(other)
-      self.class == other.class
-    end
-  end
-
-  it do
-    op = ExceptionalOperation.("amazing")
-    op._params.must_equal "amazing"
-
-    op._rollback_args.must_equal ["amazing", RuntimeError.new.extend(Comparable)]
-  end
-end