trailblazer-operation 0.10.0 → 0.11.0

data/test/callable_test.rb

@@ -1,147 +0,0 @@
-# require "test_helper"
-
-# class CallableHelper < Minitest::Spec
-#   Operation = Trailblazer::Operation
-#   Activity  = Trailblazer::Activity
-
-#   module Blog
-#     Read    = ->((options, *args), *) { options["Read"] = 1; [ Activity::Right, [options, *args] ] }
-#     Next    = ->((options, *args), *) { options["NextPage"] = []; [ options["return"], [options, *args] ] }
-#     Comment = ->((options, *args), *) { options["Comment"] = 2; [ Activity::Right, [options, *args] ] }
-#   end
-
-#   module User
-#     Relax   = ->((options, *args), *) { options["Relax"]=true; [ Activity::Right, [options, *args] ] }
-#   end
-
-#   ### Callable( )
-#   ###
-#   describe "circuit with 1 level of nesting" do # TODO: test this kind of configuration in dsl_tests somewhere.
-#     let(:blog) do
-#       Module.new do
-#         extend Activity::Path()
-
-#         task task: Blog::Read
-#         task task: Blog::Next, Output(Activity::Right, :done) => "End.success", Output(Activity::Left, :success) => Track(:success)
-#         task task: Blog::Comment
-#       end
-#     end
-
-#     let(:user) do
-#       _blog = blog
-
-#       Module.new do
-#         extend Activity::Path()
-
-#         task task: _blog, _blog.outputs[:success] => Track(:success)
-#         task task: User::Relax
-#       end
-#     end
-
-#     it "ends before comment, on next_page" do
-#       user.( [options = { "return" => Activity::Right }] ).must_equal(
-#         [user.outputs[:success].signal, [{"return"=>Trailblazer::Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true}]]
-#       )
-
-#       options.must_equal({"return"=>Trailblazer::Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true})
-#     end
-#   end
-
-#   ### Callable( End1, End2 )
-#   ###
-#   describe "circuit with 2 end events in the nested process" do
-#     let(:blog) do
-#       Module.new do
-#         extend Activity::Path()
-
-#         task task: Blog::Read
-#         task task: Blog::Next, Output(Activity::Right, :success___) => :__success, Output(Activity::Left, :retry___) => _retry=End(:retry)
-#       end
-#     end
-
-#     let(:user) do
-#       _blog = blog
-
-#       Module.new do
-#         extend Activity::Path()
-
-#         task task: _blog, _blog.outputs[:success] => Track(:success), _blog.outputs[:retry] => "End.success"
-#         task task: User::Relax
-#       end
-#     end
-
-#     it "runs from Callable->default to Relax" do
-#       user.( [ options = { "return" => Activity::Right } ] ).must_equal [
-#         user.outputs[:success].signal,
-#         [ {"return"=>Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true} ]
-#       ]
-
-#       options.must_equal({"return"=>Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true})
-#     end
-
-#     it "runs from other Callable end" do
-#       user.( [ options = { "return" => Activity::Left } ] ).must_equal [
-#         user.outputs[:success].signal,
-#         [ {"return"=>Activity::Left, "Read"=>1, "NextPage"=>[]} ]
-#       ]
-
-#       options.must_equal({"return"=>Activity::Left, "Read"=>1, "NextPage"=>[]})
-#     end
-
-#     #---
-#     #- Callable( activity, start_at )
-#     let(:with_nested_and_start_at) do
-#       _blog = blog
-
-#       Module.new do
-#         extend Activity::Path()
-
-#         task task: Operation::Callable( _blog, start_task: Blog::Next ), _blog.outputs[:success] => Track(:success)
-#         task task: User::Relax
-#       end
-#     end
-
-#     it "runs Callable from alternative start" do
-#       with_nested_and_start_at.( [options = { "return" => Activity::Right }] ).
-#         must_equal [
-#           with_nested_and_start_at.outputs[:success].signal,
-#           [ {"return"=>Activity::Right, "NextPage"=>[], "Relax"=>true} ]
-#         ]
-
-#       options.must_equal({"return"=>Activity::Right, "NextPage"=>[], "Relax"=>true})
-#     end
-
-#     #---
-#     #- Callable(  activity, call: :__call__ ) { ... }
-#     describe "Callable with :call option" do
-#       let(:process) do
-#         class Workout
-#           def self.__call__((options, *args), *)
-#             options[:workout]   = 9
-
-#             return Activity::Right, [options, *args]
-#           end
-#         end
-
-#         subprocess = Operation::Callable( Workout, call: :__call__ )
-
-#         Module.new do
-#         extend Activity::Path()
-
-#           task task: subprocess
-#           task task: User::Relax
-#         end
-#       end
-
-#       it "runs Callable process with __call__" do
-#         process.( [options = { "return" => Activity::Right }] ).
-#           must_equal [
-#             process.outputs[:success].signal,
-#             [{"return"=>Activity::Right, :workout=>9, "Relax"=>true}]
-#           ]
-
-#         options.must_equal({"return"=>Activity::Right, :workout=>9, "Relax"=>true})
-#       end
-#     end
-#   end
-# end

data/test/docs/doormat_test.rb

@@ -1,190 +0,0 @@
-require "test_helper"
-
-class TemplateWithGroupTest < Minitest::Spec
-  module Memo; end
-
-  #:template
-  class Memo::Operation < Trailblazer::Operation
-    step :log_call, group: :start
-    step :log_success,  group: :end, before: "End.success"
-    fail :log_errors,   group: :end, before: "End.failure"
-    #~tmethods
-
-    # our success "end":
-    def log_call(options, **)
-      options["row"] = [:a]
-    end
-
-    # our success "end":
-    def log_success(options, **)
-      options["row"] << :z
-    end
-
-    def log_errors(options, **)
-      options["row"] << :f
-    end
-    #~tmethods end
-  end
-  #:template end
-
-  #:template-user
-  class Memo::Create < Memo::Operation
-    step :create_model
-    step :validate
-    step :save
-    #~meths
-    def create_model(options, **)
-      options["row"] << :l
-    end
-
-    def validate(options, **)
-      options["row"] << :b
-    end
-
-    def save(options, **)
-      options["row"] << :c
-    end
-    #~meths end
-  end
-  #:template-user end
-
-  # it { pp F['__sequence__'].to_a }
-  it {
-    skip
-    Memo::Create.(params: {}, "b_return" => false).inspect("row").must_equal %{<Result:true [[:a, :l, :b, :c, :z]] >}
-  }
-end
-
-class DoormatWithGroupTest < Minitest::Spec
-  module Memo; end
-
-  #:doormat-group
-  class Memo::Create < Trailblazer::Operation
-    step :create_model
-    step :log_success, group: :end, before: "End.success"
-
-    step :validate
-    step :save
-
-    fail :log_errors, group: :end, before: "End.failure"
-    #~methods
-    def create_model(options, **)
-      options["row"] = [:a]
-    end
-
-    # our success "end":
-    def log_success(options, **)
-      options["row"] << :z
-    end
-
-    # 2
-    def validate(options, **)
-      options["row"] << :b
-    end
-
-    # 3
-    def save(options, **)
-      options["row"] << :c
-    end
-
-    def log_errors(options, **)
-      options["row"] << :f
-    end
-    #~methods end
-  end
-  #:doormat-group end
-
-  # it { pp F['__sequence__'].to_a }
-  it {
-    skip
-    Memo::Create.(params: {}, "b_return" => false).inspect("row").must_equal %{<Result:true [[:a, :b, :c, :z]] >}
-  }
-end
-
-class DoormatStepDocsTest < Minitest::Spec
-  module Memo; end
-
-  #:doormat-before
-  class Memo::Create < Trailblazer::Operation
-    step :create_model
-    step :log_success
-
-    step :validate, before: :log_success
-    step :save,     before: :log_success
-
-    fail :log_errors
-    #~im
-    def create_model(options, **)
-      options["row"] = [:a]
-    end
-
-    # our success "end":
-    def log_success(options, **)
-      options["row"] << :z
-    end
-
-    # 2
-    def validate(options, **)
-      options["row"] << :b
-    end
-
-    # 3
-    def save(options, **)
-      options["row"] << :c
-    end
-
-    def log_errors(options, **)
-      options["row"] << :f
-    end
-    #~im end
-  end
-  #:doormat-before end
-
-  # it { pp F['__sequence__'].to_a }
-  it { Memo::Create.(params: {}, "b_return" => false).inspect("row").must_equal %{<Result:true [[:a, :b, :c, :z]] >} }
-end
-
-class DoormatInheritanceTest < Minitest::Spec
-  #:doormatx-before-inheritance
-  class Base < Trailblazer::Operation
-    step :log_success!
-    fail :log_errors!
-    #~ignored
-    # our success "end":
-    def log_success!(options, **)
-      options["row"] << :z
-    end
-
-    def log_errors!(options, **)
-      options["row"] << :f
-    end
-    #~ignored end
-  end
-  #:doormatx-before-inheritance end
-
-  #:doormat-before-inheritance-sub
-  class Create < Base
-    step :first, before: :log_success!
-    step :second, before: :log_success!
-    step :third,  before: :log_success!
-    #~ignoredd
-    def first(options, **)
-      options["row"] = [:a]
-    end
-
-    # 2
-    def second(options, **)
-      options["row"] << :b
-    end
-
-    # 3
-    def third(options, **)
-      options["row"] << :c
-    end
-    #~ignoredd end
-  end
-  #:doormat-before-inheritance-sub end
-
-  # it { pp F['__sequence__'].to_a }
-  it { Create.("b_return" => false).inspect("row").must_equal %{<Result:true [[:a, :b, :c, :z]] >} }
-end

data/test/docs/macaroni_test.rb

@@ -1,31 +0,0 @@
-# require "test_helper"
-
-# class MacaroniTaskBuilderTest < Minitest::Spec
-#   Memo = Struct.new(:title) do
-#     def save
-#       self.title = title[:title].reverse
-#     end
-#   end
-
-#   #:create
-#   class Memo::Create < Trailblazer::Operation(step_interface_builder: Trailblazer::Operation::Railway::KwSignature)
-#     #~ign
-#     step :create_model
-#     step :save
-#     #~ign end
-#     #~methods
-#     def create_model(params:, options:, **)
-#       options[:model] = Memo.new(title: params[:title])
-#     end
-
-#     def save(model:, **)
-#       model.save
-#     end
-#     #~methods end
-#   end
-#   #:create end
-
-#   it "allows optional macaroni call style" do
-#     Memo::Create.(params: {title: "Wow!"}).inspect(:model).must_equal %{<Result:true [#<struct MacaroniTaskBuilderTest::Memo title=\"!woW\">] >}
-#   end
-# end

data/test/skill_test.rb

@@ -1,66 +0,0 @@
-# require "test_helper"
-# require "trailblazer/skill"
-
-# class SkillTest < Minitest::Spec
-#   it "wraps one" do
-#     options = { params: "Hello!" }
-
-#     skill = Trailblazer::Skill.new(options)
-
-#     skill[:params].must_equal "Hello!"
-
-#     skill.to_hash.must_equal( {params: "Hello!"} )
-
-#     options.inspect.must_equal %{{:params=>"Hello!"}}
-#   end
-#   # FIXME: do we actually want key?
-#   it "what" do
-#     skills = Trailblazer::Skill.new({ "a" => false, "b" => nil })
-#     (!!skills.key?("a")).must_equal true
-#     (!!skills.key?("b")).must_equal true
-#   end
-
-#   describe "Skill" do
-#     it do
-#       class_level_container = {
-#         "contract.class" => Object,
-#         "model.class" => String
-#       }
-
-#       runtime_skills = {
-#         "contract" => MyContract=Class.new,
-#         "model.class" => Integer
-#       }
-
-#       skill = Trailblazer::Skill.new(runtime_skills, class_level_container)
-
-#       # non-existent key.
-#       skill[:nope].must_be_nil
-
-#       # from runtime.
-#       skill["contract"].must_equal MyContract
-#       # from compile-time.
-#       skill["contract.class"].must_equal Object
-#       # runtime supersedes compile-time.
-#       skill["model.class"].must_equal Integer
-
-#       skill["model.class"] = Fixnum
-#       skill["model.class"].must_equal Fixnum
-
-#       # add new tuple.
-#       skill["user.current"] = "Todd"
-
-#       # original container don't get changed
-#       class_level_container.inspect.must_equal %{{"contract.class"=>Object, "model.class"=>String}}
-#       runtime_skills.inspect.must_equal %{{"contract"=>SkillTest::MyContract, "model.class"=>Integer}}
-
-#       # setting false.
-#       skill[:valid] = false
-#       skill[:valid].must_equal false
-
-#       # setting nil.
-#       skill[:valid] = nil
-#       skill[:valid].must_be_nil
-#     end
-#   end
-# end

data/test/wire_test.rb

@@ -1,113 +0,0 @@
-# require "test_helper"
-# # require "trailblazer/developer"
-
-# class WireTest < Minitest::Spec
-#   Circuit = Trailblazer::Circuit
-#   ExceptionFromD = Class.new               # custom signal
-
-#   D = ->((options, *args), *) do
-#     options["D"] = [ options["a"], options["b"], options["c"] ]
-
-#     signal = options["D_return"]
-#     [ signal, [ options, *args ] ]
-#   end
-
-#   #---
-#   #- step providing all :outputs manually.
-#   class Create < Trailblazer::Operation
-#     step ->(options, **) { options["a"] = 1 }
-#     step ->(options, **) { options["b"] = 2 }, name: "b"
-
-#     step( { task: D,
-#       outputs: { Circuit::Right => :success, Circuit::Left => :failure, ExceptionFromD => :exception }, # any outputs and their polarization, generic.
-#       id: :d,
-#       },
-#       :exception => MyEnd = End("End.ExceptionFromD_happened")
-#     )
-
-#     fail ->(options, **) { options["f"] = 4 }, id: "f"
-#     step ->(options, **) { options["c"] = 3 }, id: "c"
-#   end
-
-#   # myend ==> d
-#   it { Trailblazer::Operation::Inspect.(Create).gsub(/0x.+?wire_test.rb/, "").must_equal %{[>#<Proc::18 (lambda)>,>b,>d,<<f,>c]} }
-
-#   # normal flow as D sits on the Right track.
-#   it do
-#     result = Create.({}, "D_return" => Circuit::Right)
-
-#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:true [1, 2, 3, [1, 2, nil], nil] >}
-#     result.event.must_equal Create.outputs.keys[1]
-#   end
-
-#   # ends on MyEnd, without hitting fail.
-#   it do
-#     result = Create.({}, "D_return" => ExceptionFromD)
-
-#     result.event.must_equal Create::MyEnd
-#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], nil] >}
-#   end
-
-#   # normal flow to left track.
-#   it do
-#     result = Create.({}, "D_return" => Circuit::Left)
-
-#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], 4] >}
-#     result.event.must_equal Create.outputs.keys[0]
-#   end
-
-#   #---
-#   #- step with Merge
-#   class CreateWithDefaults < Trailblazer::Operation
-#     step ->(options, **) { options["a"] = 1 }
-#     step ->(options, **) { options["b"] = 2 }, name: "b"
-
-#     step( { task: D,
-#       outputs: Merge( ExceptionFromD => { role: :exception } ), # any outputs and their polarization, generic.
-#       id: :d,
-#       },
-#       :exception => MyEnd = End("End.ExceptionFromD_happened")
-#     )
-
-#     fail ->(options, **) { options["f"] = 4 }, id: "f"
-#     step ->(options, **) { options["c"] = 3 }, id: "c"
-#   end
-
-#   # normal flow as D sits on the Right track.
-#   it do
-#     result = CreateWithDefaults.({}, "D_return" => Circuit::Right)
-
-#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:true [1, 2, 3, [1, 2, nil], nil] >}
-#     result.event.must_equal CreateWithDefaults.outputs.keys[1]
-#   end
-
-#   # ends on MyEnd, without hitting fail.
-#   it do
-#     result = CreateWithDefaults.({}, "D_return" => ExceptionFromD)
-
-#     result.event.must_equal CreateWithDefaults::MyEnd
-#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], nil] >}
-#   end
-
-#   # normal flow to left track.
-#   it do
-#     result = CreateWithDefaults.({}, "D_return" => Circuit::Left)
-
-#     result.inspect("a", "b", "c", "D", "f").must_equal %{<Result:false [1, 2, nil, [1, 2, nil], 4] >}
-#     result.event.must_equal CreateWithDefaults.outputs.keys[0]
-#   end
-
-# end
-
-# class WireExceptionTest < Minitest::Spec
-#   # role in :outputs can't be connected because not in :connect_to.
-#   it do
-#     exception = assert_raises do
-#       class Create < Trailblazer::Operation
-#         step :a, outputs: { "some" => { role: :success } }, connect_to: { :not_existent => "End.success" }
-#       end
-#     end
-
-#     exception.message.must_equal %{Couldn't map output role :success for {:not_existent=>"End.success"}}
-#   end
-# end