functional-light-service 0.2.4

data/spec/acceptance/organizer/iterate_spec.rb

@@ -0,0 +1,37 @@
+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 '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_if_spec.rb

@@ -0,0 +1,51 @@
+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
+end

data/spec/acceptance/organizer/reduce_until_spec.rb

@@ -0,0 +1,43 @@
+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
+end

data/spec/acceptance/organizer/with_callback_spec.rb

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

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

data/spec/acceptance/skip_all_warning_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe "skip_all! has been deprecated" do
+  it "is now skip_remaining!" do
+    class SkipAllDeprecatedAction
+      extend FunctionalLightService::Action
+
+      executed do |ctx|
+        ctx.skip_all!("No need to execute other actions.")
+      end
+    end
+
+    expected_msg = "Using skip_all! has been deprecated, " \
+                   "please use `skip_remaining!` instead."
+    expect(ActiveSupport::Deprecation).to receive(:warn)
+      .with(expected_msg)
+
+    SkipAllDeprecatedAction.execute
+  end
+end

data/spec/acceptance/testing/context_factory_spec.rb

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,93 @@
+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