functional-light-service 0.5.4 → 6.0.0

data/spec/acceptance/organizer/context_failure_and_skipping_spec.rb

@@ -1,65 +1,68 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe FunctionalLightService::Organizer do
-  class TestSkipBefore
-    extend FunctionalLightService::Organizer
-    def self.call
-      with(:number => 1)
-        .reduce([
-                  TestDoubles::SkipAllAction,
-                  reduce_until(->(ctx) { ctx.number == 3 },
-                               TestDoubles::AddsOneAction)
-                ])
-    end
-  end
-
-  class TestSkipAfter
-    extend FunctionalLightService::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 TestContextFailure
-    extend FunctionalLightService::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 'respects failure across all nestings' do
-    result = TestContextFailure.call
-
-    expect(result).to be_failure
-    expect(result[:number]).to eq(1)
-  end
-end
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe FunctionalLightService::Organizer do
+  class TestSkipBefore
+    extend FunctionalLightService::Organizer
+
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  TestDoubles::SkipAllAction,
+                  reduce_until(->(ctx) { ctx.number == 3 },
+                               TestDoubles::AddsOneAction)
+                ])
+    end
+  end
+
+  class TestSkipAfter
+    extend FunctionalLightService::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 TestContextFailure
+    extend FunctionalLightService::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 '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/reduce_if_spec.rb

@@ -1,89 +1,89 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe FunctionalLightService::Organizer do
-  class TestReduceIf
-    extend FunctionalLightService::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) { FunctionalLightService::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 FunctionalLightService::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! }),
-              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
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe FunctionalLightService::Organizer do
+  class TestReduceIf
+    extend FunctionalLightService::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) { FunctionalLightService::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 FunctionalLightService::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/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