test/pipetree_test.rb in trailblazer-operation-0.0.9 vs test/pipetree_test.rb in trailblazer-operation-0.0.10

@@ -1,36 +1,30 @@
 require "test_helper"
 
 class PipetreeTest < Minitest::Spec
-  module Validate
-    def self.import!(operation, pipe)
-      pipe.(:>, ->{ snippet }, name: "validate", before: "operation.new")
-    end
+  def self.Validate
+    step = ->{ snippet }
+
+    [ step, name: "validate", before: "operation.new" ]
   end
 
-  #---
-  # ::|
   # without options
   class Create < Trailblazer::Operation
-    step [Validate]
+    step PipetreeTest::Validate()
+    step PipetreeTest::Validate(), name: "VALIDATE!"
   end
 
-  it { Create["pipetree"].inspect.must_equal %{[>validate,>>operation.new]} }
+  it { Create["pipetree"].inspect.must_equal %{[>validate,>VALIDATE!,>operation.new]} }
 
-  # without any options or []
-  # class New < Trailblazer::Operation
-  #   step Validate
-  # end
 
-  # it { New["pipetree"].inspect.must_equal %{[>validate,>>operation.new]} }
 
   # with options
   class Update < Trailblazer::Operation
-    step [Validate], after: "operation.new"
+    step PipetreeTest::Validate(), after: "operation.new"
   end
 
-  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,>validate]} }
+  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>validate]} }
 
   #---
   # ::step
 
   #-
@@ -61,43 +55,131 @@
   #---
   # ::>, ::<, ::>>, :&
   # with proc, method, callable.
   class Right < Trailblazer::Operation
     MyProc = ->(*) { }
-    self.> ->(options) { options[">"] = options["params"][:id] }, better_api: true
+    success ->(options) { options[">"] = options["params"][:id] }, better_api: true
 
-    self.> :method_name!
+    success :method_name!
     def method_name!(options); self["method_name!"] = options["params"][:id] end
 
     class MyCallable
       include Uber::Callable
       def call(options); options["callable"] = options["params"][:id] end
     end
-    self.> MyCallable.new
+    success MyCallable.new
   end
 
   it { Right.( id: 1 ).slice(">", "method_name!", "callable").must_equal [1, 1, 1] }
-  it { Right["pipetree"].inspect.must_equal %{[>>operation.new,>PipetreeTest::Right:66,>method_name!,>PipetreeTest::Right::MyCallable]} }
+  it { Right["pipetree"].inspect.must_equal %{[>operation.new,>pipetree_test.rb:60,>method_name!,>PipetreeTest::Right::MyCallable]} }
 
   #---
   # inheritance
   class Righter < Right
-    self.> ->(options) { options["righter"] = true }
+    success ->(options) { options["righter"] = true }
   end
 
   it { Righter.( id: 1 ).slice(">", "method_name!", "callable", "righter").must_equal [1, 1, 1, true] }
 end
 
-#---
-#- kw args
-class OperationKwArgsTest < Minitest::Spec
-  Song = Struct.new(:id)
 
+class FailPassFastOptionTest < Minitest::Spec
+  # #failure fails fast.
   class Create < Trailblazer::Operation
-    self.> ->(options) { options["model"] = "Object" }
-    # self.> ->(model:) { snippet }
+    step ->(options, *) { options["x"] = options["dont_fail"] }
+    failure ->(options, *) { options["a"] = true; options["fail_fast"] }, fail_fast: true
+    failure ->(options, *) { options["b"] = true }
+    step ->(options, *) { options["y"] = true }
   end
 
-  it {
-    skip
-    Create.() }
+  it { Create.({}, "fail_fast" => true, "dont_fail" => true ).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, nil, nil, true] >} }
+  it { Create.({}, "fail_fast" => true                  ).inspect("x", "a", "b", "y").must_equal %{<Result:false [nil, true, nil, nil] >} }
+  it { Create.({}, "fail_fast" => false                 ).inspect("x", "a", "b", "y").must_equal %{<Result:false [nil, true, nil, nil] >} }
+
+  # #success passes fast.
+  class Retrieve < Trailblazer::Operation
+    success ->(options, *) { options["x"] = options["dont_fail"] }, pass_fast: true
+    failure ->(options, *) { options["b"] = true }
+    step ->(options, *) { options["y"] = true }
+  end
+
+  it { Retrieve.({}, "dont_fail" => true  ).inspect("x", "b", "y").must_equal %{<Result:true [true, nil, nil] >} }
+  it { Retrieve.({}, "dont_fail" => false ).inspect("x", "b", "y").must_equal %{<Result:true [false, nil, nil] >} }
+
+  # #step fails fast if option set and returns false.
+  class Update < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true }
+    step ->(options, *) { options["a"] = options["dont_fail"] }, fail_fast: true # only on false.
+    failure ->(options, *) { options["b"] = true }
+    step ->(options, *) { options["y"] = true }
+  end
+
+  it { Update.({}, "dont_fail" => true).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, true, nil, true] >} }
+  it { Update.({}                     ).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, nil, nil] >} }
+
+  # #step passes fast if option set and returns true.
+  class Delete < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true }
+    step ->(options, *) { options["a"] = options["dont_fail"] }, pass_fast: true # only on true.
+    failure ->(options, *) { options["b"] = true }
+    step ->(options, *) { options["y"] = true }
+  end
+
+  it { Delete.({}, "dont_fail" => true).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, true, nil, nil] >} }
+  it { Delete.({}                     ).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, true, nil] >} }
+end
+
+class FailBangTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.fail! }
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, true] >} }
+end
+
+class PassBangTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.pass! }
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, true, nil] >} }
+end
+
+class FailFastBangTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.fail_fast! }
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, nil] >} }
+end
+
+class PassFastBangTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step ->(options, *) { options["x"] = true; Railway.pass_fast! }
+    step ->(options, *) { options["y"] = true }
+    failure ->(options, *) { options["a"] = true }
+  end
+
+  it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, nil, nil] >} }
+end
+
+
+class OverrideTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step :a
+    step :b
+  end
+
+  class Update < Create
+    step :a, override: true
+  end
+
+# FIXME: also test Macro
+  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>a,>b]} }
+  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>a,>b]} }
 end