switchyard 7.0.0

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH << File.join(File.dirname(__FILE__))
+
+if ENV['RUN_COVERAGE_REPORT']
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter 'vendor/'
+    add_filter %r{^/spec/}
+  end
+
+  SimpleCov.minimum_coverage 98
+  SimpleCov.minimum_coverage_by_file 90
+
+  require "simplecov-cobertura"
+  SimpleCov.formatter = SimpleCov::Formatter::CoberturaFormatter
+end
+
+# i18n non e' piu una dipendenza runtime della gem: viene caricata qui
+# per testare l'adapter I18n e la selezione automatica in Configuration
+require "i18n"
+require "switchyard"
+require "switchyard/testing"
+require "switchyard/functional/null"
+require "support"
+require "test_doubles"
+require "stringio"
+
+# Le API deprecate (Maybe/Null, operatori esotici) restano testate:
+# i warning vengono silenziati globalmente e riattivati solo nelle
+# spec che li verificano
+Switchyard::Deprecations.silenced = true

data/spec/support.rb

@@ -0,0 +1 @@
+

data/spec/test_doubles.rb

@@ -0,0 +1,656 @@
+# A collection of Action and Organizer dummies used in specs
+
+module TestDoubles
+  class RollbackAction
+    extend Switchyard::Action
+
+    executed(&:fail_with_rollback!)
+  end
+
+  class RaiseErrorAction
+    extend Switchyard::Action
+
+    executed do |_ctx|
+      raise 'A problem has occured.'
+    end
+  end
+
+  class RaiseAnotherErrorAction
+    extend Switchyard::Action
+
+    executed do |_ctx|
+      raise 'More problems'
+    end
+  end
+
+  class SkipAllAction
+    extend Switchyard::Action
+
+    executed(&:skip_remaining!)
+  end
+
+  class FailureAction
+    extend Switchyard::Action
+
+    executed(&:fail!)
+  end
+
+  class AddTwoOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context).reduce([AddsOneAction, AddsOneAction])
+    end
+  end
+
+  class AroundEachNullHandler
+    def self.call(_action)
+      yield
+    end
+  end
+
+  class TestLogger
+    attr_accessor :logs
+
+    def initialize
+      @logs = []
+    end
+  end
+
+  class AroundEachLoggerHandler
+    def self.call(context)
+      before_number = context[:number]
+      result = yield
+
+      context[:logger].logs << {
+        :action => context.current_action,
+        :before => before_number,
+        :after => result[:number]
+      }
+
+      result
+    end
+  end
+
+  class AroundEachOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(action_arguments)
+      with(action_arguments)
+        .around_each(AroundEachLoggerHandler)
+        .reduce([AddsTwoActionWithFetch])
+    end
+  end
+
+  class AddsTwoActionWithFetch
+    extend Switchyard::Action
+
+    executed do |context|
+      number = context.fetch(:number, 0)
+      context[:number] = number + 2
+    end
+  end
+
+  class AnAction
+    extend Switchyard::Action
+  end
+
+  class AnotherAction
+    extend Switchyard::Action
+  end
+
+  class AnOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(action_arguments)
+      with(action_arguments).reduce([AnAction, AnotherAction])
+    end
+
+    def self.do_something_with_no_actions(action_arguments)
+      with(action_arguments).reduce
+    end
+
+    def self.do_something_with_no_starting_context
+      reduce([AnAction, AnotherAction])
+    end
+  end
+
+  class NotExplicitlyReturningContextOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      context[:foo] = [1, 2, 3]
+    end
+  end
+
+  class NestingOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [NotExplicitlyReturningContextOrganizer, NestedAction]
+    end
+  end
+
+  class NestedAction
+    extend Switchyard::Action
+
+    expects :foo
+
+    executed do |context|
+      context[:bar] = context.foo
+    end
+  end
+
+  class MakesTeaWithMilkAction
+    extend Switchyard::Action
+
+    expects :tea, :milk
+    promises :milk_tea
+
+    executed do |context|
+      context.milk_tea = "#{context.tea} - #{context.milk}"
+    end
+  end
+
+  class MultipleExpectsAction
+    extend Switchyard::Action
+
+    expects :tea
+    expects :milk, :chocolate
+    promises :milk_tea
+
+    executed do |context|
+      context.milk_tea = "#{context.tea} - #{context.milk} " \
+                         "- with #{context.chocolate}"
+    end
+  end
+
+  class MakesCappuccinoAction
+    extend Switchyard::Action
+
+    expects :coffee, :milk
+    promises :cappuccino
+  end
+
+  class MakesLatteAction
+    extend Switchyard::Action
+
+    expects :coffee, :milk
+    promises :latte
+
+    executed do |context|
+      context.fail!("Can't make a latte from a milk that's very hot!") if context.milk == :very_hot
+
+      if context.milk == :super_hot
+        error_message = "Can't make a latte from a milk that's super hot!"
+        context.fail_with_rollback!(error_message)
+      end
+
+      context[:latte] = "#{context.coffee} - with lots of #{context.milk}"
+
+      if context.milk == "5%"
+        msg = "Can't make a latte with a fatty milk like that!"
+        context.skip_remaining!(msg)
+        next context
+      end
+    end
+  end
+
+  class MultiplePromisesAction
+    extend Switchyard::Action
+
+    expects :coffee, :milk
+    promises :cappuccino
+    promises :latte
+
+    executed do |context|
+      context.cappuccino = "Cappucino needs #{context.coffee} and a little milk"
+      context.latte = "Latte needs #{context.coffee} and a lot of milk"
+    end
+  end
+
+  class MakesTeaAndCappuccino
+    extend Switchyard::Organizer
+
+    def self.call(tea, milk, coffee)
+      with(:tea => tea, :milk => milk, :coffee => coffee)
+        .reduce(TestDoubles::MakesTeaWithMilkAction,
+                TestDoubles::MakesLatteAction)
+    end
+  end
+
+  class MakesCappuccinoAddsTwo
+    extend Switchyard::Organizer
+
+    def self.call(milk, coffee)
+      with(:milk => milk, :coffee => coffee)
+        .reduce(TestDoubles::AddsTwoActionWithFetch,
+                TestDoubles::MakesLatteAction)
+    end
+  end
+
+  class MakesCappuccinoAddsTwoAndFails
+    extend Switchyard::Organizer
+
+    def self.call(coffee, this_hot = :very_hot)
+      with(:milk => this_hot, :coffee => coffee)
+        .reduce(TestDoubles::MakesLatteAction,
+                TestDoubles::AddsTwoActionWithFetch)
+    end
+  end
+
+  class MakesCappuccinoSkipsAddsTwo
+    extend Switchyard::Organizer
+
+    def self.call(coffee)
+      with(:milk => "5%", :coffee => coffee)
+        .reduce(TestDoubles::MakesLatteAction,
+                TestDoubles::AddsTwoActionWithFetch)
+    end
+  end
+
+  class AdditionOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(number)
+      with(:number => number).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        AddsTwoAction,
+        AddsThreeAction
+      ]
+    end
+  end
+
+  class ExtraArgumentAdditionOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(number, another_number)
+      with(:number => number + another_number).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        AddsTwoAction,
+        AddsThreeAction
+      ]
+    end
+  end
+
+  class AddsOne
+    extend Switchyard::Organizer
+
+    def call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [AddsOneAction]
+    end
+  end
+
+  class AddsOneAction
+    extend Switchyard::Action
+
+    expects :number
+    promises :number
+
+    executed do |context|
+      context.number += 1
+    end
+  end
+
+  class AddsTwoAction
+    extend Switchyard::Action
+
+    expects :number
+
+    executed do |context|
+      context.number += 2
+    end
+  end
+
+  class AddsThreeAction
+    extend Switchyard::Action
+
+    expects :number
+
+    executed do |context|
+      context.number += 3
+    end
+  end
+
+  class IterateOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneIteratesAction,
+        iterate(:numbers, [
+                  AddsTwoAction,
+                  AddsThreeAction
+                ])
+      ]
+    end
+  end
+
+  class AddsOneIteratesAction
+    extend Switchyard::Action
+
+    expects :numbers
+    promises :numbers
+
+    executed do |context|
+      context.numbers = context.numbers.map { |n| n + 1 }
+    end
+  end
+
+  class CallbackOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        with_callback(AddTenCallbackAction, [
+                        AddsTwoAction,
+                        AddsThreeAction
+                      ])
+      ]
+    end
+  end
+
+  class AddTenCallbackAction
+    extend Switchyard::Action
+
+    expects :number, :callback
+
+    executed do |context|
+      context.number += 10
+      context.number =
+        context.callback.call(context).fetch(:number)
+    end
+  end
+
+  class ReduceUntilOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        reduce_until(->(ctx) { ctx.number > 3 }, [
+                       AddsTwoAction,
+                       AddsThreeAction
+                     ])
+      ]
+    end
+  end
+
+  class ReduceIfOrganizer
+    extend Switchyard::Organizer
+
+    def self.call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        reduce_if(->(ctx) { ctx.number > 1 }, [
+                    AddsTwoAction,
+                    AddsThreeAction
+                  ])
+      ]
+    end
+  end
+
+  class MakesTeaExpectingReservedKey
+    extend Switchyard::Action
+
+    expects :tea, :message
+
+    executed do |context|
+      context.product = context.number + 3
+    end
+  end
+
+  class MakesTeaExpectingMultipleReservedKeys
+    extend Switchyard::Action
+
+    expects :tea, :message, :error_code, :current_action
+
+    executed do |context|
+      context.product = context.number + 3
+    end
+  end
+
+  class MakesTeaPromisingReservedKey
+    extend Switchyard::Action
+
+    expects :tea
+    promises :product, :message
+
+    executed do |context|
+      context.product = context.number + 3
+    end
+  end
+
+  class MakesTeaPromisingMultipleReservedKeys
+    extend Switchyard::Action
+
+    expects :tea
+    promises :product, :message, :error_code, :current_action
+
+    executed do |context|
+      context.product = context.number + 3
+    end
+  end
+
+  class MakesTeaPromisingKeyButRaisesException
+    extend Switchyard::Action
+
+    promises :product
+
+    executed do |context|
+      context.product = make_product
+    end
+
+    def self.make_product
+      raise "Fail"
+    end
+    private_class_method :make_product
+  end
+
+  class PromisesPromisedKeyAction
+    extend Switchyard::Action
+
+    promises :promised_key
+
+    executed do |ctx|
+      ctx.promised_key = "promised_key"
+    end
+  end
+
+  class ExpectsExpectedKeyAction
+    extend Switchyard::Action
+
+    expects :expected_key
+    promises :final_key
+
+    executed do |ctx|
+      ctx.final_key = ctx.expected_key
+    end
+  end
+
+  class NullAction
+    extend Switchyard::Action
+
+    # rubocop:disable Lint/EmptyBlock
+    executed { |_ctx| }
+    # rubocop:enable Lint/EmptyBlock
+  end
+
+  class TestIterate
+    extend Switchyard::Organizer
+
+    def self.call(context)
+      with(context)
+        .reduce([iterate(:counters,
+                         [TestDoubles::AddsOneAction])])
+    end
+
+    def self.call_single(context)
+      with(context)
+        .reduce([iterate(:counters,
+                         TestDoubles::AddsOneAction)])
+    end
+  end
+
+  class TestWithCallback
+    extend Switchyard::Organizer
+
+    def self.call(context = {})
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        SetUpContextAction,
+        with_callback(IterateCollectionAction,
+                      [IncrementCountAction,
+                       AddToTotalAction])
+      ]
+    end
+  end
+
+  class SetUpContextAction
+    extend Switchyard::Action
+
+    promises :numbers, :counter, :total
+
+    executed do |ctx|
+      ctx.numbers = [1, 2, 3]
+      ctx.counter = 0
+      ctx.total = 0
+    end
+  end
+
+  class IterateCollectionAction
+    extend Switchyard::Action
+
+    expects :numbers, :callback
+    promises :number
+
+    executed do |ctx|
+      ctx.numbers.each do |number|
+        ctx.number = number
+        ctx.callback.call(ctx)
+      end
+    end
+  end
+
+  class IncrementCountAction
+    extend Switchyard::Action
+
+    expects :counter
+
+    executed do |ctx|
+      ctx.counter = ctx.counter + 1
+    end
+  end
+
+  class AddToTotalAction
+    extend Switchyard::Action
+
+    expects :number, :total
+
+    executed do |ctx|
+      ctx.total += ctx.number
+    end
+  end
+
+  class CapitalizeMessage
+    extend Switchyard::Action
+
+    expects :a_message
+    promises :final_message
+
+    executed do |ctx|
+      ctx.final_message = ctx.a_message.upcase
+    end
+  end
+
+  class AddsNumbersWithOptionalDefaults
+    extend Switchyard::Action
+
+    expects  :first_number
+    expects  :second_number, :default => ->(ctx) { ctx[:first_number] + 7 }
+    expects  :third_number,  :default => 10
+    promises :total
+
+    executed do |ctx|
+      ctx.total = ctx.first_number + ctx.second_number + ctx.third_number
+    end
+  end
+
+  class OrganizerWithActionsUsingDefaults
+    extend Switchyard::Organizer
+
+    def self.call
+      with(:first_number => 1, :number => 1).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsNumbersWithOptionalDefaults,
+        AddToTotalAction
+      ]
+    end
+  end
+
+  class AnOrganizerThatAddsToContext
+    extend Switchyard::Organizer
+
+    def self.call
+      with.reduce(actions)
+    end
+
+    def self.actions
+      [add_to_context(
+        :strongest_avenger => :thor,
+        :last_jedi => "Rey"
+      )]
+    end
+  end
+
+  class AnOrganizerThatAddsAliases
+    extend Switchyard::Organizer
+
+    def self.call
+      with(:foo => :bar).reduce(actions)
+    end
+
+    def self.actions
+      [add_aliases(:foo => :baz)]
+    end
+  end
+end

data/spec/testing/context_factory/iterate_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe 'ContextFactory - used with IterateOrganizer' do
+  let(:organizer) { TestDoubles::IterateOrganizer }
+
+  context 'when called with outside iterate steps' do
+    it 'creates a context up-to the action defined before the iteration' do
+      ctx =
+        Switchyard::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsOneIteratesAction)
+        .with(:numbers => [1, 2])
+
+      expect(ctx[:numbers]).to eq([1, 2])
+    end
+
+    it 'creates a context up-to iteration with empty context steps' do
+      ctx =
+        Switchyard::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsTwoAction)
+        .with(:numbers => [1, 2])
+
+      expect(ctx.numbers).to eq([2, 3])
+    end
+
+    it 'creates a context only to the first step of the iteration' do
+      ctx =
+        Switchyard::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsThreeAction)
+        .with(:numbers => [1, 2])
+
+      expect(ctx.numbers).to eq([2, 3])
+      expect(ctx.number).to eq(4)
+    end
+  end
+end