functional-light-service 0.5.4 → 6.1.0

data/spec/acceptance/organizer/with_callback_spec.rb

@@ -1,110 +1,113 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::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
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::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 FunctionalLightService::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/{not_having_call_method_warning_spec.rb → organizer_entry_point_spec.rb}

@@ -1,9 +1,9 @@
 require 'spec_helper'
 require 'test_doubles'
 
-describe "Organizer should invoke with/reduce from a call method" do
-  context "when the organizer does not have a `call` method" do
-    it "gives warning" do
+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 FunctionalLightService::Organizer
 
@@ -11,14 +11,16 @@ describe "Organizer should invoke with/reduce from a call method" do
           reduce([])
         end
       end
-      expect do
-        OrganizerWithoutCallMethod.do_something
-      end.to output(/The <OrganizerWithoutCallMethod> class is an organizer/).to_stdout
+
+      result = nil
+      expect { result = OrganizerWithoutCallMethod.do_something }
+        .not_to output.to_stdout
+      expect(result).to be_a_kind_of(FunctionalLightService::Context)
     end
   end
 
   context "when the organizer has the `call` method" do
-    it "does not issue a warning" do
+    it "works without emitting any warning" do
       class OrganizerWithCallMethod
         extend FunctionalLightService::Organizer
 
@@ -26,6 +28,7 @@ describe "Organizer should invoke with/reduce from a call method" do
           reduce([])
         end
       end
+
       expect(OrganizerWithCallMethod.call).to be_a_kind_of(FunctionalLightService::Context)
     end
   end

data/spec/acceptance/rollback_spec.rb

@@ -1,132 +1,183 @@
-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
-
-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
-end
+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