switchyard 7.0.0

data/spec/acceptance/organizer/around_each_with_reduce_if_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  class TestReduceIfWithAroundEach
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context)
+        .around_each(TestDoubles::AroundEachLoggerHandler)
+        .reduce(actions)
+    end
+
+    def self.actions
+      [
+        TestDoubles::AddsOneAction,
+        reduce_if(->(ctx) { ctx.number == 1 },
+                  TestDoubles::AddsOneAction)
+      ]
+    end
+  end
+
+  it 'can be used to log data' do
+    result =
+      TestReduceIfWithAroundEach
+      .call(:number => 0,
+            :logger => TestDoubles::TestLogger.new)
+
+    expect(result.fetch(:number)).to eq(2)
+    expect(result[:logger].logs).to eq(
+      [{
+        :action => TestDoubles::AddsOneAction,
+        :before => 0,
+        :after => 1
+      }, {
+        :action => TestDoubles::AddsOneAction,
+        :before => 1,
+        :after => 2
+      }]
+    )
+  end
+end

data/spec/acceptance/organizer/context_failure_and_skipping_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  class TestSkipBefore
+    extend Switchyard::Organizer
+
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  TestDoubles::SkipAllAction,
+                  reduce_until(->(ctx) { ctx.number == 3 },
+                               TestDoubles::AddsOneAction)
+                ])
+    end
+  end
+
+  class TestSkipAfter
+    extend Switchyard::Organizer
+
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  TestDoubles::AddsOneAction,
+                  reduce_until(->(ctx) { ctx.number == 3 }, [
+                                 TestDoubles::AddsOneAction
+                               ]),
+                  TestDoubles::SkipAllAction,
+                  TestDoubles::AddsOneAction
+                ])
+    end
+  end
+
+  class TestSkipAllFromNestedScope
+    extend Switchyard::Organizer
+
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  reduce_if(->(_ctx) { true }, [
+                              TestDoubles::AddsOneAction,
+                              execute(lambda(&:skip_all_remaining!))
+                            ]),
+                  TestDoubles::AddsOneAction
+                ])
+    end
+  end
+
+  class TestContextFailure
+    extend Switchyard::Organizer
+
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  TestDoubles::FailureAction,
+                  reduce_until(->(ctx) { ctx[:number] == 3 },
+                               TestDoubles::AddsOneAction),
+                  TestDoubles::AddsOneAction
+                ])
+    end
+  end
+
+  it 'skips all the rest of the actions' do
+    result = TestSkipBefore.call
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(1)
+  end
+
+  it 'skips after an action in nested context' do
+    result = TestSkipAfter.call
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(3)
+  end
+
+  it 'does not reset skip_all_remaining at the end of a nested scope' do
+    result = TestSkipAllFromNestedScope.call
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(2)
+  end
+
+  it 'respects failure across all nestings' do
+    result = TestContextFailure.call
+
+    expect(result).to be_failure
+    expect(result[:number]).to eq(1)
+  end
+end

data/spec/acceptance/organizer/execute_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  class TestExecute
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context).reduce(steps)
+    end
+
+    def self.steps
+      [
+        TestDoubles::AddsOneAction,
+        execute(->(ctx) { ctx.number += 1 }),
+        execute(->(ctx) { ctx[:something] = 'hello' }),
+        TestDoubles::AddsOne.actions
+      ]
+    end
+  end
+
+  let(:empty_context) { Switchyard::Context.make }
+
+  it 'calls the lambda in the execute block using the context' do
+    result = TestExecute.call(:number => 0)
+
+    expect(result).to be_success
+    expect(result.number).to eq(3)
+    expect(result[:something]).to eq('hello')
+  end
+
+  it 'will not execute a failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestExecute.call(empty_context)
+
+    expect(result).to be_failure
+  end
+
+  it 'does not execute over a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestExecute.call(empty_context)
+    expect(result).to be_success
+  end
+
+  it 'accepts a block instead of a lambda' do
+    organizer = Class.new do
+      extend Switchyard::Organizer
+
+      def self.call(context)
+        with(context).reduce(steps)
+      end
+
+      def self.steps
+        [
+          execute { |ctx| ctx[:number] += 1 }
+        ]
+      end
+    end
+
+    result = organizer.call(:number => 1)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(2)
+  end
+end

data/spec/acceptance/organizer/iterate_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  let(:empty_context) { Switchyard::Context.make }
+
+  it 'reduces each item of a collection and singularizes the collection key' do
+    result = TestDoubles::TestIterate.call(:number => 1,
+                                           :counters => [1, 2, 3, 4])
+
+    expect(result).to be_success
+    expect(result.number).to eq(5)
+  end
+
+  it 'accepts a single action or organizer' do
+    result = TestDoubles::TestIterate.call_single(:number => 1,
+                                                  :counters => [1, 2, 3, 4])
+
+    expect(result).to be_success
+    expect(result.number).to eq(5)
+  end
+
+  it "knows that it's being iterated from within an organizer" do
+    result = TestDoubles::TestIterate.call(:number => 1,
+                                           :counters => [1, 2, 3, 4])
+
+    expect(result.organized_by).to eq TestDoubles::TestIterate
+  end
+
+  it 'will not iterate over a failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestDoubles::TestIterate.call(empty_context)
+
+    expect(result).to be_failure
+  end
+
+  it 'does not iterate over a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestDoubles::TestIterate.call(empty_context)
+    expect(result).to be_success
+  end
+end

data/spec/acceptance/organizer/reduce_case_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  class TestReduceCase
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        reduce_case(
+          :value => :incr_num,
+          :when => {
+            :one => [TestDoubles::AddsOneAction],
+            :two => [TestDoubles::AddsTwoAction],
+            :three => [TestDoubles::AddsThreeAction]
+          },
+          :else => [TestDoubles::FailureAction]
+        )
+      ]
+    end
+  end
+
+  it 'adds one if the incr_num is one' do
+    result = TestReduceCase.call(:number => 0, :incr_num => :one)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(1)
+  end
+
+  it 'adds two if the incr_num is two' do
+    result = TestReduceCase.call(:number => 0, :incr_num => :two)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(2)
+  end
+
+  it 'adds three if the incr_num is three' do
+    result = TestReduceCase.call(:number => 0, :incr_num => :three)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(3)
+  end
+
+  it 'will fail if the incr_num is neither one, two, or three' do
+    result = TestReduceCase.call(:number => 0, :incr_num => :four)
+
+    expect(result).to be_failure
+  end
+
+  it 'raises ArgumentError when a mandatory keyword argument is missing' do
+    expect do
+      Class.new do
+        extend Switchyard::Organizer
+
+        def self.actions
+          [reduce_case(:value => :incr_num, :when => {})]
+        end
+      end.actions
+    end.to raise_error(ArgumentError, /Expected keyword arguments/)
+  end
+end

data/spec/acceptance/organizer/reduce_if_else_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  class TestReduceIfElse
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        TestDoubles::AddsOneAction,
+        reduce_if_else(
+          ->(ctx) { ctx.number == 1 },
+          [TestDoubles::AddsOneAction],
+          [TestDoubles::AddsTwoAction]
+        )
+      ]
+    end
+  end
+
+  let(:empty_context) { Switchyard::Context.make }
+
+  it 'reduces the if_steps if the condition is true' do
+    result = TestReduceIfElse.call(:number => 0)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(2)
+  end
+
+  it 'reduces the else_steps if the condition is false' do
+    result = TestReduceIfElse.call(:number => 2)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(5)
+  end
+
+  it 'will not reduce over a failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestReduceIfElse.call(empty_context)
+
+    expect(result).to be_failure
+  end
+
+  it 'does not reduce over a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestReduceIfElse.call(empty_context)
+    expect(result).to be_success
+  end
+
+  it "knows that it's being conditionally reduced from within an organizer" do
+    result = TestReduceIfElse.call(:number => 2)
+
+    expect(result.organized_by).to eq TestReduceIfElse
+  end
+end

data/spec/acceptance/organizer/reduce_if_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  class TestReduceIf
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        TestDoubles::AddsOneAction,
+        reduce_if(->(ctx) { ctx.number == 1 },
+                  TestDoubles::AddsOneAction)
+      ]
+    end
+  end
+
+  let(:empty_context) { Switchyard::Context.make }
+
+  it 'reduces if the block evaluates to true' do
+    result = TestReduceIf.call(:number => 0)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(2)
+  end
+
+  it 'does not reduce if the block evaluates to false' do
+    result = TestReduceIf.call(:number => 2)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(3)
+  end
+
+  it 'will not reduce over a failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestReduceIf.call(empty_context)
+
+    expect(result).to be_failure
+  end
+
+  it 'does not reduce over a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestReduceIf.call(empty_context)
+    expect(result).to be_success
+  end
+
+  it "knows that it's being conditionally reduced from within an organizer" do
+    result = TestReduceIf.call(:number => 2)
+
+    expect(result.organized_by).to eq TestReduceIf
+  end
+
+  it 'skips actions within in its own scope' do
+    org = Class.new do
+      extend Switchyard::Organizer
+
+      def self.call
+        reduce(actions)
+      end
+
+      def self.actions
+        [
+          reduce_if(
+            ->(c) { !c.nil? },
+            [
+              execute(->(c) { c[:first_reduce_if] = true }),
+              execute(->(c) { c.skip_remaining! }), # rubocop:disable Style/SymbolProc
+              execute(->(c) { c[:second_reduce_if] = true })
+            ]
+          ),
+          execute(->(c) { c[:last_outside] = true })
+        ]
+      end
+    end
+
+    result = org.call
+
+    aggregate_failures do
+      expect(result[:first_reduce_if]).to be true
+      expect(result[:second_reduce_if]).to be_nil
+      expect(result[:last_outside]).to be true
+    end
+  end
+end

data/spec/acceptance/organizer/reduce_until_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  class TestReduceUntil
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        reduce_until(->(ctx) { ctx.number == 3 },
+                     TestDoubles::AddsOneAction)
+      ]
+    end
+  end
+
+  let(:empty_context) { Switchyard::Context.make }
+
+  it 'reduces until the block evaluates to true' do
+    context = { :number => 1 }
+    result = TestReduceUntil.call(context)
+
+    expect(result).to be_success
+    expect(result.number).to eq(3)
+  end
+
+  it 'does not execute on failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestReduceUntil.call(empty_context)
+    expect(result).to be_failure
+  end
+
+  it 'does not execute a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestReduceUntil.call(empty_context)
+    expect(result).to be_success
+  end
+
+  it "is expected to know its organizer when reducing until a condition" do
+    result = TestReduceUntil.call(:number => 1)
+
+    expect(result.organized_by).to eq TestReduceUntil
+  end
+end

data/spec/acceptance/organizer/reduce_while_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  class TestReduceWhile
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        reduce_while(->(ctx) { ctx[:number] < 3 }, [
+                       TestDoubles::AddsOneAction,
+                       TestDoubles::AddsTwoAction
+                     ])
+      ]
+    end
+  end
+
+  let(:empty_context) { Switchyard::Context.make }
+
+  it 'reduces while the block evaluates to true' do
+    result = TestReduceWhile.call(:number => 0)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(3)
+  end
+
+  it 'checks the condition before each action' do
+    result = TestReduceWhile.call(:number => 2)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(3)
+  end
+
+  it 'does not execute any steps when the condition is false from the start' do
+    result = TestReduceWhile.call(:number => 5)
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(5)
+  end
+
+  it 'does not execute on failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestReduceWhile.call(empty_context)
+    expect(result).to be_failure
+  end
+
+  it 'does not execute a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestReduceWhile.call(empty_context)
+    expect(result).to be_success
+  end
+
+  it "is expected to know its organizer when reducing while a condition" do
+    result = TestReduceWhile.call(:number => 0)
+
+    expect(result.organized_by).to eq TestReduceWhile
+  end
+
+  it 'skips actions within its own scope' do
+    org = Class.new do
+      extend Switchyard::Organizer
+
+      def self.call
+        reduce(actions)
+      end
+
+      def self.actions
+        [
+          reduce_while(
+            ->(c) { !c.nil? },
+            [
+              execute(->(c) { c[:first_reduce_while] = true }),
+              execute(lambda(&:skip_remaining!)),
+              execute(->(c) { c[:second_reduce_while] = true })
+            ]
+          ),
+          execute(->(c) { c[:last_outside] = true })
+        ]
+      end
+    end
+
+    result = org.call
+
+    aggregate_failures do
+      expect(result[:first_reduce_while]).to be true
+      expect(result[:second_reduce_while]).to be_nil
+      expect(result[:last_outside]).to be true
+    end
+  end
+end