trailblazer-macro 2.1.11 → 2.1.13

data/test/docs/nested_test.rb

@@ -1,218 +0,0 @@
-require "test_helper"
-
-class NestedInput < Minitest::Spec
-  let(:edit) do
-    edit = Class.new(Trailblazer::Operation) do
-      step :c
-
-      include T.def_steps(:c)
-    end
-  end
-
-  let(:update) do
-    edit = Class.new(Trailblazer::Operation) do
-      step :d
-      include T.def_steps(:d)
-    end
-  end
-
-  class Validate < Trailblazer::Operation
-    step :validate
-    # ... more steps ...
-    include T.def_steps(:validate)
-  end
-
-  class JsonValidate < Validate
-    step :json
-    include T.def_steps(:json)
-  end
-
-  it "Nested(Edit), without any options" do
-      module A
-
-        create =
-        #:nested
-        class Create < Trailblazer::Operation
-          step :create
-          step Nested(Validate)
-          step :save
-          #~meths
-          include T.def_steps(:create, :save)
-          #~meths end
-        end
-        #:nested end
-
-        # this will print a DEPRECATION warning.
-      # success
-        create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
-      # failure in Nested
-        create.(seq: [], validate: false).inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
-      end
-  end
-
-  it "Nested(Edit), with Output rewiring" do
-    edit = self.edit
-
-    create = Class.new(Trailblazer::Operation) do
-      step :a
-      step Nested( edit ), Output(:failure) => Track(:success)
-      step :b
-
-      include T.def_steps(:a, :b)
-    end
-
-  # success
-    create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
-  # failure in Nested
-    create.(seq: [], c: false).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
-  end
-
-  it "Nested(:method)" do
-    module B
-      create =
-      #:nested-dynamic
-      class Create < Trailblazer::Operation
-        step :create
-        step Nested(:compute_nested)
-        step :save
-
-        def compute_nested(ctx, params:, **)
-          params.is_a?(Hash) ? Validate : JsonValidate
-        end
-        #~meths
-        include T.def_steps(:create, :save)
-        #~meths end
-      end
-      #:nested-dynamic end
-    # `edit` and `update` can be called from Nested()
-
-  # edit/success
-    create.(seq: [], params: {}).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
-
-  # update/success
-    create.(seq: [], params: nil).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :json, :save]] >}
-
-
-# wiring of fail:
-  # edit/failure
-    create.(seq: [], params: {}, validate: false).inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
-  # update/failure
-    create.(seq: [], params: nil, json: false).inspect(:seq).must_equal %{<Result:false [[:create, :validate, :json]] >}
-    end
-  end
-
-  it "Nested(:method), input: :my_input" do
-    module C
-      #:nested-dynamic
-      class Create < Trailblazer::Operation
-        step :create
-        step Nested(:compute_nested), input: ->(ctx, *) {{foo: :bar, seq: ctx[:seq]}}
-        step :save
-
-        def compute_nested(ctx, params:, **)
-          params.is_a?(Hash) ? Validate : JsonValidate
-        end
-
-        #~meths
-        include T.def_steps(:create, :save)
-        #~meths end
-      end
-      #:nested-dynamic end
-
-    # `edit` and `update` can be called from Nested()
-    end
-
-    C::Create.(seq: [], params: {}).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
-    C::Create.(seq: [], params: nil).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :json, :save]] >}
-  end
-
-  it "Nested(:method), with pass_fast returned from nested" do
-    class JustPassFast < Trailblazer::Operation
-      step :just_pass_fast, pass_fast: true
-      include T.def_steps(:just_pass_fast)
-    end
-
-    module D
-
-      create =
-      #:nested-with-pass-fast
-      class Create < Trailblazer::Operation
-
-        def compute_nested(ctx, **)
-          JustPassFast
-        end
-
-        step :create
-        step Nested(:compute_nested)
-        step :save
-        #~meths
-        include T.def_steps(:create, :save)
-        #~meths end
-      end
-      #:nested-with-pass-fast end
-
-      #= {#save} is still called because the {End.pass_fast} terminus is automatically wired to
-      #= the success "output" of Nested().
-      create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:create, :just_pass_fast, :save]] >}
-    end
-  end
-
-  it "Nested(:method, auto_wire: *activities) with :pass_fast => End()" do
-    module E
-      class JsonValidate < Trailblazer::Operation
-        step :validate, Output(:failure) => End(:invalid_json)
-        step :save
-        include T.def_steps(:validate, :save)
-      end
-
-      #:nested-with-auto-wire
-      class Create < Trailblazer::Operation
-        step :create
-        step Nested(:compute_nested, auto_wire: [Validate, JsonValidate]),
-          Output(:invalid_json) => End(:jsoned)
-
-        #~meths
-        def compute_nested(ctx, what:, **)
-          what
-        end
-
-        include T.def_steps(:create)
-        #~meths end
-      end
-      #:nested-with-auto-wire end
-
-
-    #@ nested {JsonValidate} ends on {End.success}
-      result = Create.(seq: [], what: JsonValidate, validate: true)
-
-      result.inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
-
-    #@ nested {JsonValidate} ends on {End.invalid_json} because validate fails.
-      result = Create.(seq: [], what: JsonValidate, validate: false)
-
-      result.inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:jsoned>}
-
-    #@ nested {JsonValidate} ends on {End.failure} because save fails.
-      result = Create.(seq: [], what: JsonValidate, save: false)
-
-      result.inspect(:seq).must_equal %{<Result:false [[:create, :validate, :save]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
-
-    #@ nested {Validate} ends on {End.failure} because validate fails.
-      result = Create.(seq: [], what: Validate, validate: false)
-
-      result.inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
-
-    #@ nested {Validate} ends on {End.success}.
-      result = Create.(seq: [], what: Validate)
-
-      result.inspect(:seq).must_equal %{<Result:true [[:create, :validate]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
-    end
-  end
-end
-
-# TODO: test with :input/:output, tracing

data/test/operation/model_test.rb

@@ -1,89 +0,0 @@
-require "test_helper"
-
-class ModelTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find(id); new(id) end
-    def self.find_by(args)
-      key, value = args.flatten
-      return nil if value.nil?
-      return new(value) if key == :id
-      new(2, value) if key == :title
-    end
-  end
-
-  #---
-  # use Model semantics, no customizations.
-  # class Create < Trailblazer::Operation
-  class Create < Trailblazer::Operation
-    step Trailblazer::Operation::Model( Song, :new )
-  end
-
-  # :new new.
-  it "initializes new model's instance" do
-    result = Create.()
-    result[:model].inspect.must_equal %{#<struct ModelTest::Song id=nil, title=nil>}
-  end
-
-  # class Update < Create
-  class Update < Trailblazer::Operation
-    step Trailblazer::Operation::Model( Song, :find )#, override: true
-  end
-
-  #---
-  #- inheritance
-
-  # :find it
-  it { Update.(params: { id: 1 })[:model].inspect.must_equal %{#<struct ModelTest::Song id=1, title=nil>} }
-
-  # inherited inspect is ok
-  it { Trailblazer::Developer.railway(Update).must_equal %{[>model.build]} }
-
-  #---
-  # :find_by, exceptionless.
-  # class Find < Trailblazer::Operation
-  class Find < Trailblazer::Operation
-    step Trailblazer::Operation::Model Song, :find_by
-    step :process
-
-    def process(options, **); options[:x] = true end
-  end
-
-  # :find_by, exceptionless.
-  # class FindByKey < Trailblazer::Operation
-  class FindByKey < Trailblazer::Operation
-    step Trailblazer::Operation::Model( Song, :find_by, :title )
-    step :process
-
-    def process(options, **); options[:x] = true end
-  end
-
-  # can't find model.
-  #- result object, model
-  it do
-    Find.(params: {id: nil})[:"result.model"].failure?.must_equal true
-    Find.(params: {id: nil})[:"x"].must_be_nil
-    Find.(params: {id: nil}).failure?.must_equal true
-  end
-
-  #- result object, model
-  it do
-    Find.(params: {id: 9})[:"result.model"].success?.must_equal true
-    Find.(params: {id: 9})[:"x"].must_equal true
-    Find.(params: {id: 9})[:model].inspect.must_equal %{#<struct ModelTest::Song id=9, title=nil>}
-  end
-
-  # can't find model by title.
-  #- result object, model
-  it do
-    FindByKey.(params: {title: nil})[:"result.model"].failure?.must_equal true
-    FindByKey.(params: {title: nil})[:"x"].must_be_nil
-    FindByKey.(params: {title: nil}).failure?.must_equal true
-  end
-
-  #- result object, model by title
-  it do
-    FindByKey.(params: {title: "Test"})[:"result.model"].success?.must_equal true
-    FindByKey.(params: {title: "Test"})[:"x"].must_equal true
-    FindByKey.(params: {title: "Test"})[:model].inspect.must_equal %{#<struct ModelTest::Song id=2, title="Test">}
-  end
-end

data/test/operation/nested_test.rb

@@ -1,98 +0,0 @@
-require 'test_helper'
-
-class NestedTest < Minitest::Spec
-  DatabaseError = Class.new(Trailblazer::Activity::Signal)
-
-  class SignUp < Trailblazer::Operation
-    def self.b(ctx, **)
-      ctx[:seq] << :b
-      return DatabaseError
-    end
-
-    step method(:b), Output(DatabaseError, :db_error) => End(:db_error)
-  end
-
-  class SignIn < Trailblazer::Operation
-    include T.def_steps(:c)
-    step :c
-  end
-
-  it "allows connection with custom output of a nested activity" do
-    create = Class.new(Trailblazer::Operation) do
-      include T.def_steps(:a, :d)
-
-      step :a
-      step Nested(SignUp), Output(:db_error) => Track(:no_user)
-      step :d, magnetic_to: :no_user
-    end
-
-    result = create.(seq: [])
-    result.inspect(:seq).must_equal %{<Result:true [[:a, :b, :d]] >}
-    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
-  end
-
-  it "allows connecting dynamically nested activities with custom output when auto wired" do
-    create = Class.new(Trailblazer::Operation) do
-      def compute_nested(ctx, what:, **)
-        what
-      end
-
-      include T.def_steps(:a, :d)
-
-      step :a
-      step Nested(:compute_nested, auto_wire: [SignUp, SignIn]), Output(:db_error) => Track(:no_user)
-      step :d, magnetic_to: :no_user
-    end
-
-    result = create.(seq: [], what: SignUp)
-    result.inspect(:seq).must_equal %{<Result:true [[:a, :b, :d]] >}
-    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
-  end
-
-  #@ unit test
-  # TODO: make me a non-Operation test.
-  it "allows using multiple Nested() per operation" do
-    create = Class.new(Trailblazer::Operation) do
-      def compute_nested(ctx, what:, **)
-        what
-      end
-
-      step Nested(:compute_nested)
-      step Nested(:compute_nested), id: :compute_nested_again
-    end
-
-    #@ we want both Nested executed
-    result = create.(seq: [], what: SignIn)
-    result.inspect(:seq).must_equal %{<Result:true [[:c, :c]] >}
-    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
-
-    result = create.wtf?(seq: [], what: SignUp)
-    result.inspect(:seq).must_equal %{<Result:false [[:b]] >}
-    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
-  end
-
-  it "raises RuntimeError if dynamically nested activities with custom output are not auto wired" do
-    exception = assert_raises RuntimeError do
-      Class.new(Trailblazer::Operation) do
-        def compute_nested(ctx, what:, **)
-          what
-        end
-
-        step Nested(:compute_nested), Output(:db_error) => Track(:no_user)
-      end
-    end
-
-    exception.inspect.must_match 'No `db_error` output found'
-  end
-
-  it "shows warning if `Nested()` is being used instead of `Subprocess()` for static activities" do
-    _, warnings = capture_io do
-      Class.new(Trailblazer::Operation) do
-        step Nested(SignUp)
-      end
-    end
-
-    warnings.must_equal %Q{[Trailblazer]#{__FILE__}: Using the `Nested()` macro with operations and activities is deprecated. Replace `Nested(NestedTest::SignUp)` with `Subprocess(NestedTest::SignUp)`.
-}
-  end
-end