switchyard 7.0.0

data/spec/acceptance/organizer/with_callback_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe Switchyard::Organizer do
+  describe 'a simple case with a single callback' do
+    it 'calls the actions defined with callback' do
+      result = TestDoubles::TestWithCallback.call
+
+      expect(result.counter).to eq(3)
+      expect(result.total).to eq(6)
+    end
+  end
+
+  describe 'a more complex example with nested callbacks' do
+    class TestWithNestedCallback
+      extend Switchyard::Organizer
+
+      def self.call(context = {})
+        with(context).reduce(actions)
+      end
+
+      def self.actions
+        [
+          SetUpNestedContextAction,
+          with_callback(IterateOuterCollectionAction,
+                        [IncrementOuterCountAction,
+                         with_callback(TestDoubles::IterateCollectionAction,
+                                       [TestDoubles::IncrementCountAction,
+                                        TestDoubles::AddToTotalAction])])
+        ]
+      end
+    end
+
+    class SetUpNestedContextAction
+      extend Switchyard::Action
+
+      promises :outer_numbers, :outer_counter,
+               :numbers, :counter, :total
+
+      executed do |ctx|
+        ctx.outer_numbers = [12, 17]
+        ctx.outer_counter = 0
+        ctx.numbers = [1, 2, 3]
+        ctx.counter = 0
+        ctx.total = 0
+      end
+    end
+
+    class IterateOuterCollectionAction
+      extend Switchyard::Action
+
+      expects :outer_numbers, :callback
+      promises :outer_number
+
+      executed do |ctx|
+        ctx.outer_numbers.each do |outer_number|
+          ctx.outer_number = outer_number
+          ctx.callback.call(ctx)
+        end
+      end
+    end
+
+    class IncrementOuterCountAction
+      extend Switchyard::Action
+
+      expects :outer_counter
+
+      executed do |ctx|
+        ctx.outer_counter = ctx.outer_counter + 1
+      end
+    end
+
+    it 'calls both the action and the nested callbacks' do
+      result = TestWithNestedCallback.call
+
+      expect(result.outer_counter).to eq(2)
+      # Counts and total are the duplicates of
+      # what you'll see in the simple spec,
+      # as the internal callback logic is called
+      # twice due to 2 items in the outer_numbers
+      # collection.
+      expect(result.counter).to eq(6)
+      expect(result.total).to eq(12)
+    end
+  end
+
+  describe 'with failed or skipped context' do
+    class TestWithFailureCallback
+      extend Switchyard::Organizer
+
+      def self.call(context = {})
+        with(context).reduce(actions)
+      end
+
+      def self.actions
+        [
+          TestDoubles::SetUpContextAction,
+          with_callback(TestDoubles::IterateCollectionAction,
+                        [TestDoubles::IncrementCountAction,
+                         TestDoubles::FailureAction])
+        ]
+      end
+    end
+
+    it 'will not process the routine' do
+      result = TestWithFailureCallback.call
+
+      expect(result).to be_failure
+      expect(result.counter).to eq(1)
+      expect(result.total).to eq(0)
+    end
+  end
+end

data/spec/acceptance/organizer_entry_point_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe "Organizer entry point" do
+  context "when the organizer entry method is not named `call`" do
+    it "works without emitting any warning" do
+      class OrganizerWithoutCallMethod
+        extend Switchyard::Organizer
+
+        def self.do_something
+          reduce([])
+        end
+      end
+
+      result = nil
+      expect { result = OrganizerWithoutCallMethod.do_something }
+        .not_to output.to_stdout
+      expect(result).to be_a_kind_of(Switchyard::Context)
+    end
+  end
+
+  context "when the organizer has the `call` method" do
+    it "works without emitting any warning" do
+      class OrganizerWithCallMethod
+        extend Switchyard::Organizer
+
+        def self.call
+          reduce([])
+        end
+      end
+
+      expect(OrganizerWithCallMethod.call).to be_a_kind_of(Switchyard::Context)
+    end
+  end
+end

data/spec/acceptance/rollback_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+require 'test_doubles'
+
+class RollbackOrganizer
+  extend Switchyard::Organizer
+
+  def self.call(number)
+    with(:number => number).reduce(
+      AddsOneWithRollbackAction,
+      TestDoubles::AddsTwoAction,
+      AddsThreeWithRollbackAction
+    )
+  end
+end
+
+class AddsOneWithRollbackAction
+  extend Switchyard::Action
+
+  expects :number
+  promises :number
+
+  executed do |context|
+    context.fail_with_rollback! if context.number.zero?
+
+    context.number += 1
+  end
+
+  rolled_back do |context|
+    context.number -= 1
+  end
+end
+
+class AddsThreeWithRollbackAction
+  extend Switchyard::Action
+
+  expects :number
+
+  executed do |context|
+    context.number = context.number + 3
+
+    context.fail_with_rollback!("I did not like this!")
+  end
+
+  rolled_back do |context|
+    context.number -= 3
+  end
+end
+
+class RollbackOrganizerWithNoRollback
+  extend Switchyard::Organizer
+
+  def self.call(number)
+    with(:number => number).reduce(
+      TestDoubles::AddsOneAction,
+      TestDoubles::AddsTwoAction,
+      AddsThreeWithNoRollbackAction
+    )
+  end
+end
+
+class AddsThreeWithNoRollbackAction
+  extend Switchyard::Action
+
+  expects :number
+
+  executed do |context|
+    context.number = context.number + 3
+
+    context.fail_with_rollback!("I did not like this!")
+  end
+end
+
+class RollbackOrganizerWithMiddleRollback
+  extend Switchyard::Organizer
+
+  def self.call(number)
+    with(:number => number).reduce(
+      TestDoubles::AddsOneAction,
+      AddsTwoActionWithRollback,
+      TestDoubles::AddsThreeAction
+    )
+  end
+end
+
+class AddsTwoActionWithRollback
+  extend Switchyard::Action
+
+  expects :number
+
+  executed do |context|
+    context.number = context.number + 2
+
+    context.fail_with_rollback!("I did not like this a bit!")
+  end
+
+  rolled_back do |context|
+    context.number -= 2
+  end
+end
+
+class RollbackOrganizerWithDuplicatedAction
+  extend Switchyard::Organizer
+
+  def self.call(ctx)
+    with(ctx).reduce(
+      TracksRollbackAction,
+      FailsOnSecondRunWithRollbackAction,
+      TracksRollbackAction,
+      FailsOnSecondRunWithRollbackAction
+    )
+  end
+end
+
+class TracksRollbackAction
+  extend Switchyard::Action
+
+  executed do |context|
+    (context[:executed] ||= []) << :tracks
+  end
+
+  rolled_back do |context|
+    (context[:rolled_back] ||= []) << :tracks
+  end
+end
+
+class FailsOnSecondRunWithRollbackAction
+  extend Switchyard::Action
+
+  executed do |context|
+    (context[:executed] ||= []) << :fails
+    context.fail_with_rollback!("boom") if context[:executed].count(:fails) == 2
+  end
+
+  rolled_back do |context|
+    (context[:rolled_back] ||= []) << :fails
+  end
+end
+
+describe "Rolling back actions when there is a failure" do
+  it "Adds 1, 2, 3 to 1 and rolls back " do
+    result = RollbackOrganizer.call 1
+    number = result.fetch(:number)
+
+    expect(result).to be_failure
+    expect(result.message).to eq("I did not like this!")
+    expect(number).to eq(3)
+  end
+
+  it "won't error out when actions don't define rollback" do
+    result = RollbackOrganizerWithNoRollback.call 1
+    number = result.fetch(:number)
+
+    expect(result).to be_failure
+    expect(result.message).to eq("I did not like this!")
+    expect(number).to eq(7)
+  end
+
+  it "rolls back properly when triggered with an action in the middle" do
+    result = RollbackOrganizerWithMiddleRollback.call 1
+    number = result.fetch(:number)
+
+    expect(result).to be_failure
+    expect(result.message).to eq("I did not like this a bit!")
+    expect(number).to eq(2)
+  end
+
+  it "rolls back from the first action" do
+    result = RollbackOrganizer.call 0
+    number = result.fetch(:number)
+
+    expect(result).to be_failure
+    expect(number).to eq(-1)
+  end
+
+  it "rolls back every executed action when the same action appears twice" do
+    result = RollbackOrganizerWithDuplicatedAction.call({})
+
+    expect(result).to be_failure
+    expect(result[:executed]).to eq(%i[tracks fails tracks fails])
+    # tutte e 4 le azioni eseguite vengono compensate, in ordine inverso
+    expect(result[:rolled_back]).to eq(%i[fails tracks fails tracks])
+  end
+end

data/spec/acceptance/skip_all_remaining_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+RSpec.describe "skip_all_remaining!" do
+  context "with regular organizer" do
+    let(:organizer) do
+      Class.new do
+        extend Switchyard::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions
+          [
+            execute(->(c) { c[:first] = true }),
+            execute(lambda(&:skip_all_remaining!)),
+            execute(->(c) { c[:second] = true })
+          ]
+        end
+      end
+    end
+
+    it "skips all remaining actions" do
+      result = organizer.call(Switchyard::Context.make)
+
+      expect(result[:first]).to be true
+      expect(result[:second]).to be_nil
+    end
+  end
+
+  context "with an organizer with a reducer" do
+    let(:organizer) do
+      Class.new do
+        extend Switchyard::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions
+          [
+            reduce_if(
+              ->(_) { true },
+              [
+                execute(->(c) { c[:first_inside] = true }),
+                execute(lambda(&:skip_all_remaining!)),
+                execute(->(c) { c[:second_inside] = true })
+              ]
+            ),
+            execute(->(c) { c[:outside] = true })
+          ]
+        end
+      end
+    end
+
+    it "skips all remaining actions inside and outside the reducer" do
+      result = organizer.call(Switchyard::Context.make)
+
+      expect(result[:first_inside]).to be true
+      expect(result[:second_inside]).to be_nil
+      expect(result[:outside]).to be_nil
+    end
+  end
+
+  context "with a message" do
+    let(:organizer) do
+      Class.new do
+        extend Switchyard::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions
+          [
+            reduce_if(
+              ->(_) { true },
+              [
+                execute(->(c) { c.skip_all_remaining!("Skipping with message") })
+              ]
+            ),
+            execute(->(c) { c[:outside] = true })
+          ]
+        end
+      end
+    end
+
+    it "preserves the message when exiting scoped reducers" do
+      result = organizer.call(Switchyard::Context.make)
+
+      expect(result.message).to eq("Skipping with message")
+      expect(result[:outside]).to be_nil
+    end
+  end
+
+  context "with an organizer with nested reducers" do
+    let(:organizer) do
+      Class.new do
+        extend Switchyard::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          [
+            reduce_if(
+              ->(_) { true },
+              [
+                iterate(:items, [
+                          execute(->(c) {
+                            c[:executed_items] ||= []
+                            c[:executed_items] << c[:item]
+                          }),
+                          execute(->(c) { c.skip_all_remaining! if c[:item] == 2 }),
+                          execute(->(c) {
+                            c[:skipped_in_iterate] ||= []
+                            c[:skipped_in_iterate] << c[:item]
+                          })
+                        ]),
+                execute(->(c) { c[:after_iterate_inside_if] = true })
+              ]
+            ),
+            execute(->(c) { c[:outside] = true })
+          ]
+        end
+      end
+    end
+
+    it "skips all remaining actions across all nested scopes" do
+      result = organizer.call(Switchyard::Context.make(:items => [1, 2, 3]))
+
+      expect(result[:executed_items]).to eq([1, 2])
+      expect(result[:skipped_in_iterate]).to eq([1])
+      expect(result[:after_iterate_inside_if]).to be_nil
+      expect(result[:outside]).to be_nil
+    end
+  end
+end

data/spec/acceptance/testing/context_factory_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'test_doubles'
+
+class AdditionOrganizerContextFactory
+  def self.make_for(action, number)
+    number += 3 # You can add more logic to prepare your context
+
+    Switchyard::Testing::ContextFactory
+      .make_from(TestDoubles::AdditionOrganizer)
+      .for(action)
+      .with(number)
+  end
+end
+
+RSpec.describe TestDoubles::AddsThreeAction do
+  it 'creates a context for the action with ContextFactory wrapper' do
+    context =
+      AdditionOrganizerContextFactory
+      .make_for(TestDoubles::AddsThreeAction, 1)
+
+    expect(context.number).to eq(7)
+  end
+
+  it 'creates a context for the action using the ContextFactory' do
+    context =
+      Switchyard::Testing::ContextFactory
+      .make_from(TestDoubles::AdditionOrganizer)
+      .for(TestDoubles::AddsThreeAction)
+      .with(4) # Context is a "glorified" hash
+
+    expect(context.number).to eq(7)
+  end
+
+  it "works with multiple arguments passed to Organizer's call method" do
+    context = Switchyard::Testing::ContextFactory
+              .make_from(TestDoubles::ExtraArgumentAdditionOrganizer)
+              .for(described_class)
+              .with(4, 2)
+
+    expect(context.number).to eq(9)
+  end
+end
+
+RSpec.describe TestDoubles::AddsTwoAction do
+  it 'does not execute a callback entirely from a ContextFactory' do
+    context = Switchyard::Testing::ContextFactory
+              .make_from(TestDoubles::CallbackOrganizer)
+              .for(described_class)
+              .with(:number => 0)
+
+    # add 1, add 10, then stop before executing first add 2
+    expect(context.number).to eq(11)
+  end
+end

data/spec/action_expected_keys_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe ":expects macro" do
+  context "when expected keys are in the context" do
+    it "can access the keys as class methods" do
+      resulting_context = TestDoubles::MakesTeaWithMilkAction.execute(
+        :tea => "black",
+        :milk => "full cream",
+        :something => "else"
+      )
+      expect(resulting_context[:milk_tea]).to eq("black - full cream")
+    end
+  end
+
+  context "when an expected key is not in the context" do
+    it "raises an Switchyard::ExpectedKeysNotInContextError" do
+      exception_msg = "expected :milk to be in the context during " \
+                      "TestDoubles::MakesTeaWithMilkAction"
+      expect do
+        TestDoubles::MakesTeaWithMilkAction.execute(:tea => "black")
+      end.to \
+        raise_error(Switchyard::ExpectedKeysNotInContextError, exception_msg)
+    end
+  end
+
+  context "when the `expects` macro is called multiple times" do
+    it "can collect expected keys " do
+      result = TestDoubles::MultipleExpectsAction.execute(
+        :tea => "black",
+        :milk => "full cream",
+        :chocolate => "dark chocolate"
+      )
+      expect(result[:milk_tea]).to \
+        eq("black - full cream - with dark chocolate")
+    end
+  end
+
+  context "when a reserved key is listed as an expected key" do
+    it "raises an error indicating a reserved key is expected" do
+      exception_msg = "promised or expected keys cannot be a reserved key: " \
+                      "[:message]"
+      expect do
+        TestDoubles::MakesTeaExpectingReservedKey.execute(:tea => "black",
+                                                          :message => "no no")
+      end.to \
+        raise_error(Switchyard::ReservedKeysInContextError, exception_msg)
+    end
+
+    it "raises an error indicating that multiple reserved keys are expected" do
+      exception_msg = "promised or expected keys cannot be a reserved key: " \
+                      "[:message, :error_code, :current_action]"
+      expect do
+        TestDoubles::MakesTeaExpectingMultipleReservedKeys
+          .execute(:tea => "black",
+                   :message => "no no",
+                   :error_code => 1,
+                   :current_action => "update")
+      end.to raise_error(Switchyard::ReservedKeysInContextError,
+                         exception_msg)
+    end
+  end
+end

data/spec/action_expects_and_promises_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe ":expects and :promises macros" do
+  describe "actions are backward compatible" do
+    class FooAction
+      extend Switchyard::Action
+
+      executed do |context|
+        baz = context.fetch :baz
+
+        bar = baz + 2
+        context[:bar] = bar
+      end
+    end
+    it "works without expects and promises" do
+      result = FooAction.execute(:baz => 3)
+      expect(result).to be_success
+      expect(result[:bar]).to eq(5)
+    end
+  end
+
+  context "when expected keys are not in context" do
+    class FooNoExpectedKeyAction
+      extend Switchyard::Action
+
+      expects :baz
+
+      executed do |context|
+        baz = context.fetch :baz
+
+        bar = baz + 2
+        context[:bar] = bar
+      end
+    end
+    it "throws an ExpectedKeysNotInContextError" do
+      # FooAction invoked with nothing in the context
+      expect { FooNoExpectedKeyAction.execute }.to \
+        raise_error(Switchyard::ExpectedKeysNotInContextError)
+    end
+  end
+
+  describe "expected keys" do
+    class FooWithReaderAction
+      extend Switchyard::Action
+
+      expects :baz
+
+      executed do |context|
+        # Notice how I use `context.baz` here
+        bar = context.baz + 2
+        context[:bar] = bar
+      end
+    end
+    it "can be accessed through a reader" do
+      result = FooWithReaderAction.execute(:baz => 3)
+      expect(result).to be_success
+      expect(result[:bar]).to eq(5)
+    end
+  end
+
+  context "when promised keys are not in context" do
+    class FooNoPromisedKeyAction
+      extend Switchyard::Action
+
+      expects :baz
+      promises :bar
+
+      executed do |context|
+        # I am not adding anything to the context
+      end
+    end
+    it "throws a PromisedKeysNotInContextError" do
+      # FooAction invoked with nothing placed in the context
+      expect { FooNoPromisedKeyAction.execute(:baz => 3) }.to \
+        raise_error(Switchyard::PromisedKeysNotInContextError)
+    end
+  end
+
+  describe "promised keys" do
+    class FooWithExpectsAndPromisesAction
+      extend Switchyard::Action
+
+      expects :baz
+      promises :bar
+
+      executed do |context|
+        # Notice how I use `context.bar` here
+        context.bar = context.baz + 2
+      end
+    end
+    it "puts the value through the accessor into the context" do
+      result = FooWithExpectsAndPromisesAction.execute(:baz => 3)
+      expect(result).to be_success
+      expect(result[:bar]).to eq(5)
+    end
+  end
+end