functional-light-service 6.2.0 → 6.3.0

data/spec/acceptance/rollback_spec.rb

@@ -1,183 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-class RollbackOrganizer
-  extend FunctionalLightService::Organizer
-
-  def self.call(number)
-    with(:number => number).reduce(
-      AddsOneWithRollbackAction,
-      TestDoubles::AddsTwoAction,
-      AddsThreeWithRollbackAction
-    )
-  end
-end
-
-class AddsOneWithRollbackAction
-  extend FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::Organizer
-
-  def self.call(number)
-    with(:number => number).reduce(
-      TestDoubles::AddsOneAction,
-      TestDoubles::AddsTwoAction,
-      AddsThreeWithNoRollbackAction
-    )
-  end
-end
-
-class AddsThreeWithNoRollbackAction
-  extend FunctionalLightService::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 FunctionalLightService::Organizer
-
-  def self.call(number)
-    with(:number => number).reduce(
-      TestDoubles::AddsOneAction,
-      AddsTwoActionWithRollback,
-      TestDoubles::AddsThreeAction
-    )
-  end
-end
-
-class AddsTwoActionWithRollback
-  extend FunctionalLightService::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 FunctionalLightService::Organizer
-
-  def self.call(ctx)
-    with(ctx).reduce(
-      TracksRollbackAction,
-      FailsOnSecondRunWithRollbackAction,
-      TracksRollbackAction,
-      FailsOnSecondRunWithRollbackAction
-    )
-  end
-end
-
-class TracksRollbackAction
-  extend FunctionalLightService::Action
-
-  executed do |context|
-    (context[:executed] ||= []) << :tracks
-  end
-
-  rolled_back do |context|
-    (context[:rolled_back] ||= []) << :tracks
-  end
-end
-
-class FailsOnSecondRunWithRollbackAction
-  extend FunctionalLightService::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

@@ -1,139 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe "skip_all_remaining!" do
-  context "with regular organizer" do
-    let(:organizer) do
-      Class.new do
-        extend FunctionalLightService::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(FunctionalLightService::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 FunctionalLightService::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(FunctionalLightService::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 FunctionalLightService::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(FunctionalLightService::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 FunctionalLightService::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(FunctionalLightService::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

@@ -1,54 +0,0 @@
-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
-
-    FunctionalLightService::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 =
-      FunctionalLightService::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 = FunctionalLightService::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 = FunctionalLightService::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

@@ -1,63 +0,0 @@
-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 FunctionalLightService::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(FunctionalLightService::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(FunctionalLightService::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(FunctionalLightService::ReservedKeysInContextError,
-                         exception_msg)
-    end
-  end
-end

data/spec/action_expects_and_promises_spec.rb

@@ -1,97 +0,0 @@
-require 'spec_helper'
-
-describe ":expects and :promises macros" do
-  describe "actions are backward compatible" do
-    class FooAction
-      extend FunctionalLightService::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 FunctionalLightService::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(FunctionalLightService::ExpectedKeysNotInContextError)
-    end
-  end
-
-  describe "expected keys" do
-    class FooWithReaderAction
-      extend FunctionalLightService::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 FunctionalLightService::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(FunctionalLightService::PromisedKeysNotInContextError)
-    end
-  end
-
-  describe "promised keys" do
-    class FooWithExpectsAndPromisesAction
-      extend FunctionalLightService::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

data/spec/action_optional_expected_keys_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-describe ":expects macro using defaults" do
-  context "when all expected keys are supplied" do
-    it "is expected to ignore default values" do
-      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
-        :first_number => 3,
-        :second_number => 5,
-        :third_number => 7
-      )
-
-      expect(outcome.total).to eq 15
-    end
-  end
-
-  context "when defaults are supplied" do
-    it "is expected to use static values" do
-      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
-        :first_number => 3,
-        :second_number => 7
-      )
-
-      expect(outcome.total).to eq 20
-    end
-
-    it "is expected to use dynamic values" do
-      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
-        :first_number => 3,
-        :third_number => 5
-      )
-
-      expect(outcome.total).to eq 18
-    end
-
-    it "is expected to process defaults in their defined order" do
-      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
-        :third_number => 5,
-        :first_number => 3
-      )
-
-      expect(outcome.total).to eq 18
-    end
-
-    it "is expected to use all defaults if required" do
-      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
-        :first_number => 3
-      )
-
-      expect(outcome.total).to eq 23
-    end
-  end
-
-  context "when used within an organizer" do
-    it "is expected to process required defaults" do
-      outcome = TestDoubles::OrganizerWithActionsUsingDefaults.call
-
-      expect(outcome.total).to eq 20
-    end
-  end
-
-  context "when the expected key is satisfied through an alias" do
-    it "is expected to not apply the default" do
-      action = Class.new do
-        extend FunctionalLightService::Action
-
-        expects  :greeting, :default => "hello"
-        promises :greeted
-
-        executed do |ctx|
-          ctx.greeted = ctx.greeting
-        end
-      end
-
-      organizer = Class.new do
-        extend FunctionalLightService::Organizer
-
-        aliases :salutation => :greeting
-      end
-
-      outcome = organizer.with(:salutation => "ciao").reduce([action])
-
-      expect(outcome.greeted).to eq "ciao"
-    end
-  end
-
-  context "when defaults are misconfigured" do
-    it "is expected to raise an exception" do
-      expect do
-        # Needs to be specified in the block
-        # as error is raised at define time
-        class AddsNumbersWithIncorrectDefaults
-          extend FunctionalLightService::Action
-
-          expects  :first,  :default => 10 # This one is fine. Other two arent
-          expects  :second, :defalut => ->(ctx) { ctx[:first] + 7 }
-          expects  :third,  :deafult => 10
-          promises :total
-
-          executed do |ctx|
-            ctx.total = ctx.first + ctx.second + ctx.third
-          end
-        end
-      end.to raise_error(FunctionalLightService::UnusableExpectKeyDefaultError)
-    end
-  end
-end