trailblazer-macro 2.1.10.beta1 → 2.1.12

data/test/docs/macro_test.rb

@@ -31,6 +31,24 @@ class DocsMacroTest < Minitest::Spec
   it { Trailblazer::Developer.railway(Create).must_equal %{[>my_policy.manager]} }
 end
 
+
+class MacroAssignVariableTest < Minitest::Spec
+  it do
+    my_exec_context = Class.new do
+      def my_dataset(ctx, my_array:, **)
+        my_array.reverse
+      end
+    end.new
+
+    dataset_task = Trailblazer::Macro.task_adapter_for_decider(:my_dataset, variable_name: :dataset)
+
+    signal, (ctx, _) = dataset_task.([{my_array: [1,2]}, {}], exec_context: my_exec_context)
+
+    assert_equal signal, Trailblazer::Activity::Right
+    assert_equal ctx.inspect, %{{:my_array=>[1, 2], :dataset=>[2, 1]}}
+  end
+end
+
 # injectable option
 # nested pipe
 # using macros in macros

data/test/docs/model_test.rb

@@ -15,122 +15,149 @@ class DocsModelTest < Minitest::Spec
   end
 
   #:op
-  class Create < Trailblazer::Operation
-    step Model(Song, :new)
-    # ..
+  module Song::Activity
+    class Create < Trailblazer::Activity::Railway
+      step Model(Song, :new)
+      step :validate
+      step :save
+      #~meths
+      include T.def_steps(:validate, :save)
+      #~meths end
+    end
   end
   #:op end
 
+  #:update
+  module Song::Activity
+    class Update < Trailblazer::Activity::Railway
+      step Model(Song, :find_by)
+      step :validate
+      step :save
+      #~meths
+      include T.def_steps(:validate, :save)
+      #~meths end
+    end
+  end
+  #:update end
 
   it "defaults {:params} to empty hash when not passed" do
-    result = Create.({})
-    assert_equal true, result.success?
-    assert_equal %{#<struct DocsModelTest::Song id=nil, title=nil>}, result[:model].inspect
+    assert_invoke Song::Activity::Create, seq: "[:validate, :save]",
+      expected_ctx_variables: {model: Song.new}
 
-    result = Update.({})
-    assert_equal false, result.success?
-    assert_equal "nil", result[:model].inspect
+    assert_invoke Song::Activity::Update, seq: "[]",
+      terminus: :failure
   end
 
+  #~ctx_to_result
   it do
     #:create
-    result = Create.(params: {})
-    result[:model] #=> #<struct Song id=nil, title=nil>
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Create, params: {}, seq: [])
+    puts ctx[:model] #=> #<struct Song id=nil, title=nil>
     #:create end
 
-    result[:model].inspect.must_equal %{#<struct DocsModelTest::Song id=nil, title=nil>}
+    assert_invoke Song::Activity::Create, params: {},
+      seq: "[:validate, :save]", expected_ctx_variables: {model: Song.new}
   end
 
+  it do
+    #:update-ok
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Update, params: {id: 1}, seq: [])
+    ctx[:model] #=> #<Song id=1, ...>
+    puts signal #=> #<Trailblazer::Activity::End semantic=:success>
+    #:update-ok end
 
-  #:update
-  class Update < Trailblazer::Operation
-    step Model( Song, :find_by )
-    # ..
+    assert_equal ctx[:model].inspect, %{#<struct #{Song} id=1, title=nil>}
+    assert_equal signal.to_h[:semantic], :success
   end
-  #:update end
 
-  #:update-with-find-by-key
-  class UpdateWithFindByKey < Trailblazer::Operation
-    step Model( Song, :find_by, :title )
-    # ..
-  end
-  #:update-with-find-by-key end
+  it do
+    #:update-fail
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Update, params: {})
+    ctx[:model] #=> nil
+    puts signal #=> #<Trailblazer::Activity::End semantic=:failure>
+    #:update-fail end
 
-  #:update-with-not-found-end
-  class UpdateFailureWithModelNotFound < Trailblazer::Operation
-    step Model( Song, :find_by, not_found_terminus: true )
-    # ..
+    assert_equal ctx[:model].inspect, %{nil}
+    assert_equal signal.to_h[:semantic], :failure
   end
-  #:update-with-not-found-end end
+  #~ctx_to_result end
+end
 
-  it do
-    #:update-ok
-    result = Update.(params: { id: 1 })
-    result[:model] #=> #<struct Song id=1, title="nil">
-    #:update-ok end
+class DocsModelFindByTitleTest < Minitest::Spec
+  Song = Class.new(DocsModelTest::Song)
 
-    result[:model].inspect.must_equal %{#<struct DocsModelTest::Song id=1, title=nil>}
+  #:update-with-find-by-key
+  module Song::Activity
+    class Update < Trailblazer::Activity::Railway
+      step Model(Song, :find_by, :title) # third positional argument.
+      step :validate
+      step :save
+      #~meths
+      include T.def_steps(:validate, :save)
+      #~meths end
+    end
   end
+  #:update-with-find-by-key end
 
+  #~ctx_to_result
   it do
     #:update-with-find-by-key-ok
-    result = UpdateWithFindByKey.(params: { title: "Test" } )
-    result[:model] #=> #<struct Song id=2, title="Test">
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Update, params: {title: "Test"}, seq: [])
+    ctx[:model] #=> #<struct Song id=2, title="Test">
     #:update-with-find-by-key-ok end
 
-    result[:model].inspect.must_equal %{#<struct DocsModelTest::Song id=2, title="Test">}
+    assert_equal ctx[:model].inspect, %{#<struct #{Song} id=2, title="Test">}
   end
 
   it do
-    #:update-fail
-    result = Update.(params: {})
-    result[:model] #=> nil
-    result.success? #=> false
-    #:update-fail end
-    result[:model].must_be_nil
-    result.success?.must_equal false
-  end
-
-  it do
-    #:update-with-find-by-key-fail
-    result = UpdateWithFindByKey.(params: {title: nil})
-    result[:model] #=> nil
-    result.success? #=> false
-    #:update-with-find-by-key-fail end
-    result[:model].must_be_nil
-    result.success?.must_equal false
+    #:key-title-fail
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Update, params: {title: nil}, seq: [])
+    assert_equal ctx[:model].inspect, %{nil}
+    #:key-title-fail end
   end
+  #~ctx_to_result end
+end
 
-  it do
-    #:update-with-not-found-end-use
-    result = UpdateFailureWithModelNotFound.(params: {title: nil})
-    result[:model] #=> nil
-    result.success? #=> false
-    result.event #=> #<Trailblazer::Activity::End semantic=:not_found>
-    #:update-with-not-found-end-use end
-
-    result[:model].must_be_nil
-    result.success?.must_equal false
-    result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:not_found>}
-  end
+class DocsModelAccessorTest < Minitest::Spec
+  Song = Class.new(DocsModelTest::Song)
 
   #:show
-  class Show < Trailblazer::Operation
-    step Model( Song, :[] )
-    # ..
+  module Song::Activity
+    class Update < Trailblazer::Activity::Railway
+      step Model(Song, :[])
+      step :validate
+      step :save
+      #~meths
+      include T.def_steps(:validate, :save)
+      #~meths end
+    end
   end
   #:show end
 
+  #~ctx_to_result
   it do
-    result = Show.(params: { id: 1 })
-
     #:show-ok
-    result = Show.(params: { id: 1 })
-    result[:model] #=> #<struct Song id=1, title="Roxanne">
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Update, params: {id: 1}, seq: [])
+    ctx[:model] #=> #<struct Song id=1, title="Roxanne">
     #:show-ok end
 
-    result.success?.must_equal true
-    result[:model].inspect.must_equal %{#<struct DocsModelTest::Song id=100, title=nil>}
+    assert_equal ctx[:model].inspect, %{#<struct #{Song} id=100, title=nil>}
+  end
+  #~ctx_to_result end
+end
+
+class DocsModelDependencyInjectionTest < Minitest::Spec
+  Song = Class.new(DocsModelTest::Song)
+
+  module Song::Activity
+    class Create < Trailblazer::Activity::Railway
+      step Model(Song, :new)
+      step :validate
+      step :save
+      #~meths
+      include T.def_steps(:validate, :save)
+      #~meths end
+    end
   end
 
   it "allows injecting {:model.class} and friends" do
@@ -138,37 +165,126 @@ class DocsModelTest < Minitest::Spec
     end
 
     #:di-model-class
-    result = Create.(params: {}, :"model.class" => Hit)
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Create, params: {}, :"model.class" => Hit, seq: [])
     #:di-model-class end
 
-    result[:model].inspect.must_equal %{#<struct DocsModelTest::Hit id=nil, title=nil>}
+    assert_equal ctx[:model].inspect, %{#<struct #{Hit} id=nil, title=nil>}
 
   # inject all variables
     #:di-all
-    result = Create.(
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Create,
       params:               {title: "Olympia"}, # some random variable.
       "model.class":        Hit,
       "model.action":       :find_by,
-      "model.find_by_key": :title
+      "model.find_by_key":  :title, seq: []
     )
     #:di-all end
 
-    result[:model].inspect.must_equal %{#<struct DocsModelTest::Hit id=2, title="Olympia">}
+    assert_equal ctx[:model].inspect, %{#<struct #{Hit} id=2, title="Olympia">}
+end
 
   # use empty Model() and inject {model.class} and {model.action}
-    module A
-      #:op-model-empty
+class DocsModelEmptyDITest < Minitest::Spec
+  Song = Class.new(DocsModelTest::Song)
+  Hit  = Class.new(Song)
+
+  #:op-model-empty
+  module Song::Activity
+    class Create < Trailblazer::Activity::Railway
+      step Model()
+      step :validate
+      step :save
+      #~meths
+      include T.def_steps(:validate, :save)
+      #~meths end
+    end
+    #:op-model-empty end
+  end
+
+  it do
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Create, params: {}, :"model.class" => Hit, seq: [])
+    assert_equal ctx[:model].inspect, %{#<struct #{Hit} id=nil, title=nil>}
+  end
+end
+
+class DocsModelIOTest < Minitest::Spec
+  Song = Class.new(DocsModelTest::Song)
+  Hit  = Class.new(Song)
+
+  it "allows to use composable I/O with macros" do
+    #:in
+    module Song::Activity
       class Create < Trailblazer::Operation
-        step Model()
-        # ..
+        step Model(Song, :find_by),
+          In() => ->(ctx, my_id:, **) { ctx.merge(params: {id: my_id}) } # Model() needs {params[:id]}.
+        # ...
       end
-      #:op-model-empty end
-    end # A
+    end
+    #:in end
+
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Create, params: {}, my_id: 1, :"model.class" => Hit)
+    assert_equal ctx[:model].inspect, %{#<struct #{Hit} id=1, title=nil>}
+=begin
+#:in-call
+result = Create.(my_id: 1)
+#:in-call end
+=end
+    end
+  end
+end
 
-    result = A::Create.(params: {}, :"model.class" => Hit)
+class Model404TerminusTest < Minitest::Spec
+  Song = Class.new(DocsModelTest::Song)
+  #:update-with-not-found-end
+  module Song::Activity
+    class Update < Trailblazer::Activity::Railway
+      step Model(Song, :find_by, not_found_terminus: true)
+      step :validate
+      step :save
+      #~meths
+      include T.def_steps(:validate, :save)
+      #~meths end
+    end
+  end
+  #:update-with-not-found-end end
 
-    result[:model].inspect.must_equal %{#<struct DocsModelTest::Hit id=nil, title=nil>}
+  it do
+    assert_invoke Song::Activity::Update, params: {id: 1},
+      seq: "[:validate, :save]", expected_ctx_variables: {model: Song.find_by(id: 1)}
+    assert_invoke Song::Activity::Update, params: {id: nil}, terminus: :not_found
+
+    #:not_found
+    signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Update, params: {id: nil})
+    puts signal #=> #<Trailblazer::Activity::End semantic=:not_found>
+    #:not_found end
+  end
+end
 
+class Model404TerminusTest < Minitest::Spec
+  Song = Class.new(DocsModelTest::Song)
+  #:update-with-not-found-end
+  class Song
+    module Activity
+      class Update < Trailblazer::Activity::Railway
+        step Model(Song, :find_by, not_found_terminus: true)
+        step :validate
+        step :save
+        #~meths
+        include T.def_steps(:validate, :save)
+        #~meths end
+      end
+    end
+  end
+  #:update-with-not-found-end end
 
+  it do
+    assert_invoke Song::Activity::Update, params: {id: 1},
+      seq: "[:validate, :save]", expected_ctx_variables: {model: Song.find_by(id: 1)}
+    assert_invoke Song::Activity::Update, params: {id: nil}, terminus: :not_found
+
+    #:not_found
+    signal, (ctx, _) = Trailblazer::Activity::TaskWrap.invoke(Song::Activity::Update, [{params: {id: nil}},{}])
+    puts signal #=> #<Trailblazer::Activity::End semantic=:not_found>
+    #:not_found end
   end
 end