trailblazer-operation 0.0.13 → 0.1.1

data/test/result_test.rb

@@ -1,26 +1,32 @@
-require "test_helper"
+  require "test_helper"
+
+class RailwayResultTest < Minitest::Spec
+  Result  = Trailblazer::Operation::Railway::Result
+  Success = Trailblazer::Operation::Railway::End::Success
+
+  let(:event)    { Success.new(nil) }
+  let (:success) { Result.new(true, { "x"=> String }, event) }
 
-class ResultTest < Minitest::Spec
-  Result = Trailblazer::Operation::Result
-  let (:success) { Result.new(true, "x"=> String) }
   it { success.success?.must_equal true }
   it { success.failure?.must_equal false }
+  it { success.event.must_equal event }
+
   # it { success["success?"].must_equal true }
   # it { success["failure?"].must_equal false }
   it { success["x"].must_equal String }
-  it { success["not-existant"].must_equal nil }
+  it { success["not-existant"].must_be_nil }
   it { success.slice("x").must_equal [String] }
 
   #---
   # inspect
   it { success.inspect.must_equal %{<Result:true {\"x\"=>String} >} }
-  it { Result.new(true, "x"=> true, "y"=>1, "z"=>2).inspect("z", "y").must_equal %{<Result:true [2, 1] >} }
+  it { Result.new(true, { "x"=> true, "y"=>1, "z"=>2 }, event).inspect("z", "y").must_equal %{<Result:true [2, 1] >} }
 
   class Create < Trailblazer::Operation
     success :call
 
-    def call(*)
-      self[:message] = "Result objects are actually quite handy!"
+    def call(options, **)
+      options[:message] = "Result objects are actually quite handy!"
     end
   end
 

data/test/ruby-2.0.0/operation_test.rb

@@ -0,0 +1,73 @@
+require "test_helper"
+
+class DeclarativeApiTest < Minitest::Spec
+  #---
+  #- step, pass, fail
+
+  # Test: step/pass/fail
+  # * do they deviate properly?
+  class Create < Trailblazer::Operation
+    step :decide!
+    success :wasnt_ok!
+    success :was_ok!
+    failure :return_true!
+    failure :return_false!
+
+    def decide!(options, decide:raise, **o)
+      options["a"] = true
+      decide
+    end
+
+    def wasnt_ok!(options, **o)
+      options["y"] = false
+    end
+
+    def was_ok!(options, **o)
+      options["x"] = true
+    end
+
+    def return_true! (options, **o); options["b"] = true end
+    def return_false!(options, **o); options["c"] = false end
+  end
+
+  it { Create.({}, decide: true).inspect("a", "x", "y", "b", "c").must_equal %{<Result:true [true, true, false, nil, nil] >} }
+  it { Create.({}, decide: false).inspect("a", "x", "y", "b", "c").must_equal %{<Result:false [true, nil, nil, true, false] >} }
+
+  #---
+  #- trace
+
+  it do
+
+  end
+
+  #---
+  #- empty class
+  class Noop < Trailblazer::Operation
+  end
+
+  it { Noop.().inspect("params").must_equal %{<Result:true [{}] >} }
+
+  #---
+  #- pass
+  #- fail
+  class Update < Trailblazer::Operation
+    pass ->(options, **o)         { options["a"] = false }
+    step ->(options, params:raise, **o) { options["b"] = params[:decide] }
+    fail ->(options, **o)         { options["c"] = true }
+  end
+
+  it { Update.(decide: true).inspect("a", "b", "c").must_equal %{<Result:true [false, true, nil] >} }
+  it { Update.(decide: false).inspect("a", "b", "c").must_equal %{<Result:false [false, false, true] >} }
+end
+
+
+=begin
+module MiniTest::Assertions
+  def assert_inspect(text, subject)
+    circuit, _ = subject.values
+    map, _ = circuit.to_fields
+    map.inspect.gsub(/0x.+?lambda\)/, "").gsub("Trailblazer::Circuit::", "").gsub("AlterTest::", "").must_equal(text)
+  end
+end
+Trailblazer::Circuit::Activity.infect_an_assertion :assert_inspect, :must_inspect
+=end

data/test/ruby-2.0.0/step_test.rb

@@ -0,0 +1,136 @@
+require "test_helper"
+
+# Tests
+# ---  step ->(*o) { snippet }
+# ---  step Callable
+# ---  step :method
+# ---  step MyMacro
+class StepTest < Minitest::Spec
+  class Callable
+    def self.call(options, b:nil, **o)
+      options["b"] = b
+    end
+  end
+
+  module Implementation
+    module_function
+    def c(options, c:nil, **o)
+      options["c"] = c
+    end
+  end
+
+  MyMacro = ->( direction, options, flow_options ) do
+    options["e"] = options[:e]
+
+    [ direction, options, flow_options ]
+  end
+
+  class Create < Trailblazer::Operation
+    step ->(options, a:nil, **o) { options["a"] = a }
+    step Callable
+    step Implementation.method(:c)
+    step :d
+    step [ MyMacro, {} ] # doesn't provide runner_options.
+
+    def d(options, d:nil, **o)
+      options["d"] = d
+    end
+  end
+
+  it { Create.({}, a: 1, b: 2, c: 3, d: 4, e: 5).inspect("a", "b", "c", "d", "e").must_equal "<Result:true [1, 2, 3, 4, 5] >" }
+
+  it { Trailblazer::Operation::Inspect.(Create).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::29 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>[#<Proc::22 (lambda)>, {}]]} }
+  # poor test to make sure we pass debug information to Activity.
+  it { Create["__activity__"].graph.find_all(:d).first[:id].must_equal :d }
+
+  #---
+  #- :before, :after, :replace, :delete, :override
+  class A < Trailblazer::Operation
+    step :a!
+    def a!(options, **o); options["a"] = 1; end
+    def a!(options, **o); options["a"] = 1; end if RUBY_VERSION == "2.0.0"
+  end
+
+  class B < A
+    step :b!, before: :a!
+    step :c!, before: :a!
+    step :d!, after:  :b!
+  end
+
+  it { Trailblazer::Operation::Inspect.(B).must_equal %{[>b!,>d!,>c!,>a!]} }
+
+  class C < B
+    step :e!, replace: :c!
+    step nil, delete: :d!
+  end
+
+  it { Trailblazer::Operation::Inspect.(C).must_equal %{[>b!,>e!,>a!]} }
+
+  class D < Trailblazer::Operation
+    step :a!
+    step :b!
+    step :b!, override: true
+  end
+
+  it { Trailblazer::Operation::Inspect.(D).must_equal %{[>a!,>b!]} }
+
+  # not existent :name
+  it do
+    err = assert_raises Trailblazer::Operation::Railway::Sequence::IndexError  do
+      class E < Trailblazer::Operation
+        step :a, before: "I don't exist!"
+      end
+    end
+
+    err.inspect.must_equal "#<Trailblazer::Operation::Railway::Sequence::IndexError: I don't exist!>"
+  end
+
+  #---
+  #- :name
+  #-   step :whatever, name: :validate
+  class Index < Trailblazer::Operation
+    step :validate!, name: "my validate"
+    step :persist!
+    step [ MyMacro, name: "I win!" ]
+    step [ MyMacro, name: "I win!" ], name: "No, I do!"
+  end
+
+  it { Trailblazer::Operation::Inspect.(Index).must_equal %{[>my validate,>persist!,>I win!,>No, I do!]} }
+
+  #---
+  #- inheritance
+  class New < Create
+  end
+
+  it { Trailblazer::Operation::Inspect.(New).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::29 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>[#<Proc::22 (lambda)>, {}]]} }
+
+  class Update < Create
+    step :after_save!
+  end
+
+  it { Trailblazer::Operation::Inspect.(Update).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::29 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>[#<Proc::22 (lambda)>, {}],>after_save!]} }
+end
+
+#---
+#- Macros with the old `input` arg.
+#  step [ ->(input, options) { } ]
+class StepWithDeprecatedMacroTest < Minitest::Spec # TODO: remove me in 2.2.
+  class Create < Trailblazer::Operation
+    MyOutdatedMacro = ->(input, options) {
+      options["x"] = input.class
+    }
+
+    class AnotherOldMacro
+      def self.call(input, options)
+        options["y"] = input.class
+      end
+    end
+
+    step [ MyOutdatedMacro, name: :outdated ]
+    step [ AnotherOldMacro, name: :oldie ]
+  end
+
+  it { Trailblazer::Operation::Inspect.(Create).gsub(/0x.+?step_test.rb/, "").must_equal %{[>outdated,>oldie]} }
+  it { Create.().inspect("x", "y").must_equal %{<Result:true [StepWithDeprecatedMacroTest::Create, StepWithDeprecatedMacroTest::Create] >} }
+end
+

data/test/skill_test.rb

@@ -1,48 +1,66 @@
-require "test_helper"
-require "trailblazer/skill"
-
-class SkillTest < Minitest::Spec
-  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_equal 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_equal nil
-    end
-  end
-end
+# 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/step_test.rb

@@ -0,0 +1,228 @@
+require "test_helper"
+
+# Tests
+# ---  step ->(*) { snippet }
+# ---  step Callable
+# ---  step :method
+# ---  step MyMacro
+class StepTest < Minitest::Spec
+  class Callable
+    def self.call(options, b:nil, **)
+      options["b"] = b
+    end
+  end
+
+  module Implementation
+    module_function
+    def c(options, c:nil, **)
+      options["c"] = c
+    end
+  end
+
+  MyMacro = ->( (options, flow_options), * ) do
+    options["e"] = options[:e]
+
+    [ Trailblazer::Activity::Right, options, flow_options ]
+  end
+
+  class Create < Trailblazer::Operation
+    step ->(options, a:nil, **) { options["a"] = a }
+    step Callable
+    step Implementation.method(:c)
+    step :d
+    step( { task: MyMacro, id: "MyMacro" } ) # doesn't provide `runner_options` and `outputs`.
+
+    def d(options, d:nil, **)
+      options["d"] = d
+    end
+  end
+
+  it { Create.(a: 1, b: 2, c: 3, d: 4, e: 5).inspect("a", "b", "c", "d", "e").must_equal "<Result:true [1, 2, 3, 4, 5] >" }
+
+  it { Trailblazer::Operation::Inspect.(Create).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::29 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>MyMacro]} }
+
+  #---
+  #- :before, :after, :replace, :delete, :override
+  class A < Trailblazer::Operation
+    step :a!
+    def a!(options, **); options["order"] << "a" ; end
+  end
+
+  class B < A
+    step :b!, before: :a!
+    step :c!, before: :a!
+    step :d!, after:  :b!
+
+    def b!(options, **); options["order"] << "b" ; end
+    def c!(options, **); options["order"] << "c" ; end
+    def d!(options, **); options["order"] << "d" ; end
+  end
+
+  it { Trailblazer::Operation::Inspect.(B).must_equal %{[>b!,>d!,>c!,>a!]} }
+
+  class C < B
+    step :e!, replace: :c!
+    step "nil", delete: :d!
+    def e!(options, **); options["order"] << "e" ; end
+  end
+
+  it { Trailblazer::Operation::Inspect.(C).must_equal %{[>b!,>e!,>a!]} }
+  it { C.("order"=>[]).inspect("order").must_equal %{<Result:true [["b", "e", "a"]] >} }
+
+  #---
+  #- override: true
+  class D < Trailblazer::Operation
+    step :a!
+    step :add!
+    step :add!, id: :another_add!#, override: true
+
+    def a!(options, **);   options["a"] = []; end
+    def add!(options, **); options["a"] << :b; end
+  end
+
+  it { Trailblazer::Operation::Inspect.(D).must_equal %{[>a!,>add!,>another_add!]} }
+  it { D.().inspect("a").must_equal %{<Result:true [[:b, :b]] >} }
+
+  class E < Trailblazer::Operation
+    step :a!
+    step :add!
+    step :add!, override: true
+
+    def a!(options, **);   options["a"] = []; end
+    def add!(options, **); options["a"] << :b; end
+  end
+
+  it { Trailblazer::Operation::Inspect.(E).must_equal %{[>a!,>add!]} }
+  it { E.().inspect("a").must_equal %{<Result:true [[:b]] >} }
+
+  #- with proc
+  class F < Trailblazer::Operation
+    step :a!
+    step ->(options, **) { options["a"] << :b }, id: "add"
+    step ->(options, **) { options["a"] << :b }, replace: "add", id: "add!!!"
+
+    def a!(options, **);   options["a"] = []; end
+  end
+
+  it { Trailblazer::Operation::Inspect.(F).must_equal %{[>a!,>add!!!]} }
+  it { F.().inspect("a").must_equal %{<Result:true [[:b]] >} }
+
+  #- with macro
+  class G < Trailblazer::Operation
+    MyMacro1 = ->((options, flow_options), *) { options["a"] << :b; [ Trailblazer::Activity::Right, options, flow_options ] }
+    MyMacro2 = ->((options, flow_options), *) { options["a"] << :b; [ Trailblazer::Activity::Right, options, flow_options ] }
+    # MyMacro3 = ->(options, flow_options) { options["a"] << :b; [ Trailblazer::Activity::Right, options, flow_options ] }
+
+    step :a!
+    step( { task: MyMacro1, id: "add" })
+    step( { task: MyMacro2, id: "add" }, replace: "add")
+    # step [ MyMacro3, {id: "add"}, {} ], override: true
+
+    def a!(options, **);   options["a"] = []; end
+  end
+
+  it { Trailblazer::Operation::Inspect.(G).must_equal %{[>a!,>add]} }
+  it { G.().inspect("a").must_equal %{<Result:true [[:b]] >} }
+
+  # override: true in inherited class with macro
+  class Go < G
+    MyMacro = ->((options, flow_options), *) { options["a"] << :m; [ Trailblazer::Activity::Right, options, flow_options ] }
+    step task: MyMacro, override: true, id: "add"
+  end
+
+  it { Trailblazer::Operation::Inspect.(Go).must_equal %{[>a!,>add]} }
+  it { Go.().inspect("a").must_equal %{<Result:true [[:m]] >} }
+
+  #- with inheritance
+  class H < Trailblazer::Operation
+    step :a!
+    step :add!
+
+    def a!(options, **);   options["a"] = []; end
+    def add!(options, **); options["a"] << :b; end
+  end
+
+  class Hh < H
+    step :_add!, replace: :add!
+
+    def _add!(options, **); options["a"] << :hh; end
+  end
+
+  it { Trailblazer::Operation::Inspect.(Hh).must_equal %{[>a!,>_add!]} }
+  it { Hh.().inspect("a").must_equal %{<Result:true [[:hh]] >} }
+
+  #- inheritance unit test
+  class I < Trailblazer::Operation
+    step :a
+  end
+
+  class Ii < I
+    step :a, override: true
+  end
+
+  # FIXME: we have all fast track ends here.
+  it { skip;Ii["__activity__"].circuit.instance_variable_get(:@map).size.must_equal 6 }
+
+  #---
+  #-
+  # not existent :name
+  it do
+    assert_raises Trailblazer::Activity::Schema::Sequence::IndexError  do
+
+      Class.new(Trailblazer::Operation) do
+        step :a, before: "I don't exist!"
+      end
+
+    end.inspect.must_equal "#<Trailblazer::Activity::Schema::Sequence::IndexError: I don't exist!>"
+  end
+
+  #---
+  #- :name
+  #-   step :whatever, id: :validate
+  class Index < Trailblazer::Operation
+    step :validate!, id: "my validate"
+    step :persist!
+    step( { task: MyMacro, id: "I win!" })
+    step( { task: MyMacro, id: "I win!" }, id: "No, I do!")
+  end
+
+  it { Trailblazer::Operation::Inspect.(Index).must_equal %{[>my validate,>persist!,>I win!,>No, I do!]} }
+
+  #---
+  #- inheritance
+  class New < Create
+  end
+
+  it { Trailblazer::Operation::Inspect.(New).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::29 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>MyMacro]} }
+
+  class Update < Create
+    step :after_save!
+  end
+
+  it { Trailblazer::Operation::Inspect.(Update).gsub(/0x.+?step_test.rb/, "").must_equal %{[>#<Proc::29 (lambda)>,>StepTest::Callable,>#<Method: StepTest::Implementation.c>,>d,>MyMacro,>after_save!]} }
+end
+
+#---
+#- Macros with the old `input` arg.
+#  step [ ->(input, options) { } ]
+class StepWithDeprecatedMacroTest < Minitest::Spec # TODO: remove me in 2.2.
+  class Create < Trailblazer::Operation
+    MyOutdatedMacro = ->(input, options) {
+      options["x"] = input.class
+    }
+
+    class AnotherOldMacro
+      def self.call(input, options)
+        options["y"] = input.class
+      end
+    end
+
+    step [ MyOutdatedMacro, id: :outdated ]
+    step [ AnotherOldMacro, id: :oldie ]
+  end
+
+  it { Trailblazer::Operation::Inspect.(Create).gsub(/0x.+?step_test.rb/, "").must_equal %{[>outdated,>oldie]} }
+  it { Create.().inspect("x", "y").must_equal %{<Result:true [StepWithDeprecatedMacroTest::Create, StepWithDeprecatedMacroTest::Create] >} }
+end
+
+# TODO: test failure and success aliases properly.