functional-light-service 6.2.0 → 6.3.0

data/spec/acceptance/organizer/execute_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe FunctionalLightService::Organizer do
-  class TestExecute
-    extend FunctionalLightService::Organizer
-
-    def self.call(context)
-      with(context).reduce(steps)
-    end
-
-    def self.steps
-      [
-        TestDoubles::AddsOneAction,
-        execute(->(ctx) { ctx.number += 1 }),
-        execute(->(ctx) { ctx[:something] = 'hello' }),
-        TestDoubles::AddsOne.actions
-      ]
-    end
-  end
-
-  let(:empty_context) { FunctionalLightService::Context.make }
-
-  it 'calls the lambda in the execute block using the context' do
-    result = TestExecute.call(:number => 0)
-
-    expect(result).to be_success
-    expect(result.number).to eq(3)
-    expect(result[:something]).to eq('hello')
-  end
-
-  it 'will not execute a failed context' do
-    empty_context.fail!('Something bad happened')
-
-    result = TestExecute.call(empty_context)
-
-    expect(result).to be_failure
-  end
-
-  it 'does not execute over a skipped context' do
-    empty_context.skip_remaining!('No more needed')
-
-    result = TestExecute.call(empty_context)
-    expect(result).to be_success
-  end
-
-  it 'accepts a block instead of a lambda' do
-    organizer = Class.new do
-      extend FunctionalLightService::Organizer
-
-      def self.call(context)
-        with(context).reduce(steps)
-      end
-
-      def self.steps
-        [
-          execute { |ctx| ctx[:number] += 1 }
-        ]
-      end
-    end
-
-    result = organizer.call(:number => 1)
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(2)
-  end
-end

data/spec/acceptance/organizer/iterate_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe FunctionalLightService::Organizer do
-  let(:empty_context) { FunctionalLightService::Context.make }
-
-  it 'reduces each item of a collection and singularizes the collection key' do
-    result = TestDoubles::TestIterate.call(:number => 1,
-                                           :counters => [1, 2, 3, 4])
-
-    expect(result).to be_success
-    expect(result.number).to eq(5)
-  end
-
-  it 'accepts a single action or organizer' do
-    result = TestDoubles::TestIterate.call_single(:number => 1,
-                                                  :counters => [1, 2, 3, 4])
-
-    expect(result).to be_success
-    expect(result.number).to eq(5)
-  end
-
-  it "knows that it's being iterated from within an organizer" do
-    result = TestDoubles::TestIterate.call(:number => 1,
-                                           :counters => [1, 2, 3, 4])
-
-    expect(result.organized_by).to eq TestDoubles::TestIterate
-  end
-
-  it 'will not iterate over a failed context' do
-    empty_context.fail!('Something bad happened')
-
-    result = TestDoubles::TestIterate.call(empty_context)
-
-    expect(result).to be_failure
-  end
-
-  it 'does not iterate over a skipped context' do
-    empty_context.skip_remaining!('No more needed')
-
-    result = TestDoubles::TestIterate.call(empty_context)
-    expect(result).to be_success
-  end
-end

data/spec/acceptance/organizer/reduce_case_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe FunctionalLightService::Organizer do
-  class TestReduceCase
-    extend FunctionalLightService::Organizer
-
-    def self.call(context)
-      with(context).reduce(actions)
-    end
-
-    def self.actions
-      [
-        reduce_case(
-          :value => :incr_num,
-          :when => {
-            :one => [TestDoubles::AddsOneAction],
-            :two => [TestDoubles::AddsTwoAction],
-            :three => [TestDoubles::AddsThreeAction]
-          },
-          :else => [TestDoubles::FailureAction]
-        )
-      ]
-    end
-  end
-
-  it 'adds one if the incr_num is one' do
-    result = TestReduceCase.call(:number => 0, :incr_num => :one)
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(1)
-  end
-
-  it 'adds two if the incr_num is two' do
-    result = TestReduceCase.call(:number => 0, :incr_num => :two)
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(2)
-  end
-
-  it 'adds three if the incr_num is three' do
-    result = TestReduceCase.call(:number => 0, :incr_num => :three)
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(3)
-  end
-
-  it 'will fail if the incr_num is neither one, two, or three' do
-    result = TestReduceCase.call(:number => 0, :incr_num => :four)
-
-    expect(result).to be_failure
-  end
-
-  it 'raises ArgumentError when a mandatory keyword argument is missing' do
-    expect do
-      Class.new do
-        extend FunctionalLightService::Organizer
-
-        def self.actions
-          [reduce_case(:value => :incr_num, :when => {})]
-        end
-      end.actions
-    end.to raise_error(ArgumentError, /Expected keyword arguments/)
-  end
-end

data/spec/acceptance/organizer/reduce_if_else_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe FunctionalLightService::Organizer do
-  class TestReduceIfElse
-    extend FunctionalLightService::Organizer
-
-    def self.call(context)
-      with(context).reduce(actions)
-    end
-
-    def self.actions
-      [
-        TestDoubles::AddsOneAction,
-        reduce_if_else(
-          ->(ctx) { ctx.number == 1 },
-          [TestDoubles::AddsOneAction],
-          [TestDoubles::AddsTwoAction]
-        )
-      ]
-    end
-  end
-
-  let(:empty_context) { FunctionalLightService::Context.make }
-
-  it 'reduces the if_steps if the condition is true' do
-    result = TestReduceIfElse.call(:number => 0)
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(2)
-  end
-
-  it 'reduces the else_steps if the condition is false' do
-    result = TestReduceIfElse.call(:number => 2)
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(5)
-  end
-
-  it 'will not reduce over a failed context' do
-    empty_context.fail!('Something bad happened')
-
-    result = TestReduceIfElse.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 = TestReduceIfElse.call(empty_context)
-    expect(result).to be_success
-  end
-
-  it "knows that it's being conditionally reduced from within an organizer" do
-    result = TestReduceIfElse.call(:number => 2)
-
-    expect(result.organized_by).to eq TestReduceIfElse
-  end
-end

data/spec/acceptance/organizer/reduce_if_spec.rb

@@ -1,89 +0,0 @@
-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/reduce_until_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe FunctionalLightService::Organizer do
-  class TestReduceUntil
-    extend FunctionalLightService::Organizer
-
-    def self.call(context)
-      with(context).reduce(actions)
-    end
-
-    def self.actions
-      [
-        reduce_until(->(ctx) { ctx.number == 3 },
-                     TestDoubles::AddsOneAction)
-      ]
-    end
-  end
-
-  let(:empty_context) { FunctionalLightService::Context.make }
-
-  it 'reduces until the block evaluates to true' do
-    context = { :number => 1 }
-    result = TestReduceUntil.call(context)
-
-    expect(result).to be_success
-    expect(result.number).to eq(3)
-  end
-
-  it 'does not execute on failed context' do
-    empty_context.fail!('Something bad happened')
-
-    result = TestReduceUntil.call(empty_context)
-    expect(result).to be_failure
-  end
-
-  it 'does not execute a skipped context' do
-    empty_context.skip_remaining!('No more needed')
-
-    result = TestReduceUntil.call(empty_context)
-    expect(result).to be_success
-  end
-
-  it "is expected to know its organizer when reducing until a condition" do
-    result = TestReduceUntil.call(:number => 1)
-
-    expect(result.organized_by).to eq TestReduceUntil
-  end
-end

data/spec/acceptance/organizer/reduce_while_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-RSpec.describe FunctionalLightService::Organizer do
-  class TestReduceWhile
-    extend FunctionalLightService::Organizer
-
-    def self.call(context)
-      with(context).reduce(actions)
-    end
-
-    def self.actions
-      [
-        reduce_while(->(ctx) { ctx[:number] < 3 }, [
-                       TestDoubles::AddsOneAction,
-                       TestDoubles::AddsTwoAction
-                     ])
-      ]
-    end
-  end
-
-  let(:empty_context) { FunctionalLightService::Context.make }
-
-  it 'reduces while the block evaluates to true' do
-    result = TestReduceWhile.call(:number => 0)
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(3)
-  end
-
-  it 'checks the condition before each action' do
-    result = TestReduceWhile.call(:number => 2)
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(3)
-  end
-
-  it 'does not execute any steps when the condition is false from the start' do
-    result = TestReduceWhile.call(:number => 5)
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(5)
-  end
-
-  it 'does not execute on failed context' do
-    empty_context.fail!('Something bad happened')
-
-    result = TestReduceWhile.call(empty_context)
-    expect(result).to be_failure
-  end
-
-  it 'does not execute a skipped context' do
-    empty_context.skip_remaining!('No more needed')
-
-    result = TestReduceWhile.call(empty_context)
-    expect(result).to be_success
-  end
-
-  it "is expected to know its organizer when reducing while a condition" do
-    result = TestReduceWhile.call(:number => 0)
-
-    expect(result.organized_by).to eq TestReduceWhile
-  end
-
-  it 'skips actions within its own scope' do
-    org = Class.new do
-      extend FunctionalLightService::Organizer
-
-      def self.call
-        reduce(actions)
-      end
-
-      def self.actions
-        [
-          reduce_while(
-            ->(c) { !c.nil? },
-            [
-              execute(->(c) { c[:first_reduce_while] = true }),
-              execute(lambda(&:skip_remaining!)),
-              execute(->(c) { c[:second_reduce_while] = true })
-            ]
-          ),
-          execute(->(c) { c[:last_outside] = true })
-        ]
-      end
-    end
-
-    result = org.call
-
-    aggregate_failures do
-      expect(result[:first_reduce_while]).to be true
-      expect(result[:second_reduce_while]).to be_nil
-      expect(result[:last_outside]).to be true
-    end
-  end
-end

data/spec/acceptance/organizer/with_callback_spec.rb

@@ -1,113 +0,0 @@
-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/organizer_entry_point_spec.rb

@@ -1,35 +0,0 @@
-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 FunctionalLightService::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(FunctionalLightService::Context)
-    end
-  end
-
-  context "when the organizer has the `call` method" do
-    it "works without emitting any warning" do
-      class OrganizerWithCallMethod
-        extend FunctionalLightService::Organizer
-
-        def self.call
-          reduce([])
-        end
-      end
-
-      expect(OrganizerWithCallMethod.call).to be_a_kind_of(FunctionalLightService::Context)
-    end
-  end
-end