functional-light-service 0.2.4

data/spec/acceptance/before_actions_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe 'Action before_actions' do
+  describe 'works with simple organizers - from outside' do
+    it 'can be used to inject code block before each action' do
+      TestDoubles::AdditionOrganizer.before_actions = ->(ctx) do
+        ctx.number -= 2 if ctx.current_action == TestDoubles::AddsThreeAction
+      end
+
+      result = TestDoubles::AdditionOrganizer.call(0)
+
+      expect(result.fetch(:number)).to eq(4)
+    end
+
+    it 'works with iterator' do
+      TestDoubles::TestIterate.before_actions = [
+        ->(ctx) { ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction }
+      ]
+
+      result = TestDoubles::TestIterate.call(:number => 0,
+                                             :counters => [1, 2, 3, 4])
+
+      expect(result).to be_success
+      expect(result.number).to eq(-4)
+    end
+  end
+
+  describe 'can be added to organizers declaratively' do
+    module BeforeActions
+      class AdditionOrganizer
+        extend FunctionalLightService::Organizer
+        before_actions (->(ctx) do
+                          ctx.number -= 2 if ctx.current_action == TestDoubles::AddsOneAction
+                        end),
+                       (->(ctx) do
+                         ctx.number -= 3 if ctx.current_action == TestDoubles::AddsThreeAction
+                       end)
+
+        def self.call(number)
+          with(:number => number).reduce(actions)
+        end
+
+        def self.actions
+          [
+            TestDoubles::AddsOneAction,
+            TestDoubles::AddsTwoAction,
+            TestDoubles::AddsThreeAction
+          ]
+        end
+      end
+    end
+
+    it 'accepts before_actions hook lambdas from organizer' do
+      result = BeforeActions::AdditionOrganizer.call(0)
+
+      expect(result.fetch(:number)).to eq(1)
+    end
+  end
+
+  describe 'works with callbacks' do
+    it 'can interact with actions from the outside' do
+      TestDoubles::TestWithCallback.before_actions = [
+        ->(ctx) { ctx.total -= 1000 if ctx.current_action == TestDoubles::AddToTotalAction }
+      ]
+      result = TestDoubles::TestWithCallback.call
+
+      expect(result.counter).to eq(3)
+      expect(result.total).to eq(-2994)
+    end
+  end
+
+  describe 'can halt all execution with a raised error' do
+    it 'does not call the rest of the callback steps' do
+      class SkipContextError < StandardError
+        attr_reader :ctx
+
+        def initialize(msg, ctx)
+          @ctx = ctx
+          super(msg)
+        end
+      end
+      TestDoubles::TestWithCallback.before_actions = [
+        ->(ctx) do
+          if ctx.current_action == TestDoubles::IncrementCountAction
+            ctx.total -= 1000
+            raise SkipContextError.new("stop context now", ctx)
+          end
+        end
+      ]
+      begin
+        TestDoubles::TestWithCallback.call
+      rescue SkipContextError => e
+        expect(e.ctx).not_to be_empty
+      end
+    end
+  end
+end

data/spec/acceptance/custom_log_from_organizer_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "Log from an organizer with a custom logger" do
+  context "when overriding the global FunctionalLightService organizer" do
+    let(:global_logger_organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.call(number)
+          with(:number => number).reduce(actions)
+        end
+
+        def self.actions
+          [
+            TestDoubles::AddsOneAction,
+            TestDoubles::AddsTwoAction,
+            TestDoubles::AddsThreeAction
+          ]
+        end
+      end
+    end
+
+    let(:global_logger_string) { StringIO.new }
+
+    let(:custom_logger_string) { StringIO.new }
+    let(:custom_logger_organizer) do
+      custom_logger = Logger.new(custom_logger_string)
+
+      Class.new do
+        extend FunctionalLightService::Organizer
+        log_with custom_logger
+
+        def self.call(coffee, this_hot = :very_hot)
+          with(:milk => this_hot, :coffee => coffee)
+            .reduce(TestDoubles::MakesLatteAction,
+                    TestDoubles::AddsTwoActionWithFetch)
+        end
+      end
+    end
+
+    before do
+      @original_global_logger = FunctionalLightService::Configuration.logger
+      FunctionalLightService::Configuration.logger = Logger.new(global_logger_string)
+    end
+
+    it "logs in own logger" do
+      global_logger_organizer.call(1)
+      custom_logger_organizer.call(:coffee => "Cappucino")
+
+      expect(custom_logger_string.string).to include("MakesLatteAction")
+      expect(custom_logger_string.string).to_not include("AddsOneAction")
+      expect(global_logger_string.string).to include("AddsOneAction")
+      expect(global_logger_string.string).to_not include("MakesLatteAction")
+    end
+
+    after do
+      FunctionalLightService::Configuration.logger = @original_global_logger
+    end
+  end
+end

data/spec/acceptance/fail_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe "fail! returns immediately from executed block" do
+  class FailAction
+    extend FunctionalLightService::Action
+    promises :one, :two
+
+    executed do |ctx|
+      ctx.one = 1
+      # Have to set it in Context
+      ctx.two = nil
+
+      ctx.fail_and_return!('Something went wrong')
+      ctx.two = 2
+    end
+  end
+
+  it "returns immediately from executed block" do
+    result = FailAction.execute
+
+    expect(result).to be_failure
+    expect(result.two).to be_nil
+  end
+end

data/spec/acceptance/include_warning_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe "Including is discouraged" do
+  context "when including FunctionalLightService::Organizer" do
+    it "gives warning" do
+      expected_msg = "including FunctionalLightService::Organizer is deprecated. " \
+                     "Please use `extend FunctionalLightService::Organizer` instead"
+      expect(ActiveSupport::Deprecation).to receive(:warn)
+        .with(expected_msg)
+
+      class OrganizerIncludingLS
+        include FunctionalLightService::Organizer
+      end
+    end
+  end
+
+  context "when including FunctionalLightService::Action" do
+    it "gives warning" do
+      expected_msg = "including FunctionalLightService::Action is deprecated. " \
+                     "Please use `extend FunctionalLightService::Action` instead"
+      expect(ActiveSupport::Deprecation).to receive(:warn)
+        .with(expected_msg)
+
+      class ActionIncludingLS
+        include FunctionalLightService::Action
+      end
+    end
+  end
+end

data/spec/acceptance/log_from_organizer_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+require 'test_doubles'
+require 'stringio'
+
+describe "Logs from organizer" do
+  def collects_log
+    original_logger = FunctionalLightService::Configuration.logger
+
+    strio = StringIO.new
+    FunctionalLightService::Configuration.logger = Logger.new(strio)
+
+    yield
+
+    FunctionalLightService::Configuration.logger = original_logger
+
+    strio.string
+  end
+
+  context "when every action has expects or promises" do
+    subject(:log_message) do
+      collects_log do
+        TestDoubles::MakesTeaAndCappuccino
+          .call("black tea", "2% milk", "espresso coffee")
+      end
+    end
+
+    it "describes what organizer was invoked" do
+      organizer_log_message = "[FunctionalLightService] - calling organizer " \
+                              "<TestDoubles::MakesTeaAndCappuccino>"
+      expect(log_message).to include(organizer_log_message)
+    end
+
+    it "describes the actions invoked" do
+      organizer_log_message = "[FunctionalLightService] - executing " \
+                              "<TestDoubles::MakesTeaWithMilkAction>"
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "[FunctionalLightService] - executing " \
+                              "<TestDoubles::MakesLatteAction>"
+      expect(log_message).to include(organizer_log_message)
+    end
+
+    it "lists the keys in context before the actions are executed" do
+      organizer_log_message = "[FunctionalLightService] -     " \
+                              "keys in context: :tea, :milk, :coffee"
+      expect(log_message).to include(organizer_log_message)
+    end
+
+    it "lists the expects actions are expecting" do
+      organizer_log_message = "[FunctionalLightService] -   expects: :tea, :milk"
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "[FunctionalLightService] -   expects: :coffee, :milk"
+      expect(log_message).to include(organizer_log_message)
+    end
+
+    it "lists the promises actions are promising" do
+      organizer_log_message = "[FunctionalLightService] -   promises: :milk_tea"
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "[FunctionalLightService] -   promises: :latte"
+      expect(log_message).to include(organizer_log_message)
+    end
+
+    it "lists the keys in contect after the actions are executed" do
+      organizer_log_message = "[FunctionalLightService] -     keys in context: " \
+                              ":tea, :milk, :coffee, :milk_tea, :latte"
+      expect(log_message).to include(organizer_log_message)
+    end
+  end
+
+  context "when NOT every action expects or promises" do
+    subject(:log_message) do
+      collects_log do
+        TestDoubles::MakesCappuccinoAddsTwo.call("2% milk", "espresso coffee")
+      end
+    end
+
+    it "describes what organizer was invoked" do
+      organizer_log_message = "[FunctionalLightService] - calling organizer " \
+                              "<TestDoubles::MakesCappuccinoAddsTwo>"
+      expect(log_message).to include(organizer_log_message)
+    end
+
+    it "does not list empty expects or promises" do
+      organizer_log_message = "[FunctionalLightService] -   expects:\n"
+      expect(log_message).not_to include(organizer_log_message)
+      organizer_log_message = "[FunctionalLightService] -   promises:\n"
+      expect(log_message).not_to include(organizer_log_message)
+    end
+  end
+
+  context "when the context has failed" do
+    subject(:log_message) do
+      collects_log do
+        TestDoubles::MakesCappuccinoAddsTwoAndFails
+          .call("espresso coffee")
+      end
+    end
+
+    it "logs it with a warning" do
+      organizer_log_message = "WARN -- : [FunctionalLightService] - :-((( " \
+                              "<TestDoubles::MakesLatteAction> has failed..."
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "WARN -- : [FunctionalLightService] - context message: " \
+                              "Can't make a latte from a milk that's very hot!"
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "[FunctionalLightService] -  :-((( " \
+                              "<TestDoubles::AddsTwoAction> has failed..."
+      expect(log_message).not_to include(organizer_log_message)
+    end
+  end
+
+  context "when the context has failed with rollback" do
+    subject(:log_message) do
+      collects_log do
+        TestDoubles::MakesCappuccinoAddsTwoAndFails
+          .call("espresso coffee", :super_hot)
+      end
+    end
+
+    it "logs it with a warning" do
+      organizer_log_message = "WARN -- : [FunctionalLightService] - :-((( " \
+                              "<TestDoubles::MakesLatteAction> has failed..."
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "WARN -- : [FunctionalLightService] - context message: " \
+                              "Can't make a latte from a milk that's super hot!"
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "[FunctionalLightService] -  :-((( " \
+                              "<TestDoubles::AddsTwoAction> " \
+                              "has failed..."
+      expect(log_message).not_to include(organizer_log_message)
+    end
+  end
+
+  context "when the context is skipping the rest" do
+    subject(:log_message) do
+      collects_log do
+        TestDoubles::MakesCappuccinoSkipsAddsTwo.call("espresso coffee")
+      end
+    end
+
+    it "logs it with a warning" do
+      organizer_log_message = "INFO -- : [FunctionalLightService] - ;-) " \
+                              "<TestDoubles::MakesLatteAction> has decided " \
+                              "to skip the rest of the actions"
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "INFO -- : [FunctionalLightService] - context message: " \
+                              "Can't make a latte with a fatty milk like that!"
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "INFO -- : [FunctionalLightService] - ;-) " \
+                              "<TestDoubles::AddsTwoAction> has decided " \
+                              "to skip the rest of the actions"
+      expect(log_message).not_to include(organizer_log_message)
+    end
+  end
+end

data/spec/acceptance/message_localization_spec.rb

@@ -0,0 +1,118 @@
+require "spec_helper"
+require "test_doubles"
+
+class TestsLocalizationAdapter
+  extend FunctionalLightService::Organizer
+
+  def self.call(pass_or_fail, message_or_key, i18n_options = {})
+    with(
+      :pass_or_fail => pass_or_fail,
+      :message_or_key => message_or_key,
+      :i18n_options => i18n_options
+    ).reduce(TestsLocalizationInvocationOptionsAction)
+  end
+end
+
+class TestsLocalizationInvocationOptionsAction
+  extend FunctionalLightService::Action
+  expects :pass_or_fail, :message_or_key, :i18n_options
+
+  executed do |context|
+    if context.pass_or_fail == true
+      context.succeed!(context.message_or_key, context.i18n_options)
+    else
+      context.fail!(context.message_or_key, context.i18n_options)
+    end
+  end
+end
+
+def pass_with(message_or_key, i18n_options = {})
+  TestsLocalizationAdapter.call(true, message_or_key, i18n_options)
+end
+
+def fail_with(message_or_key, i18n_options = {})
+  TestsLocalizationAdapter.call(false, message_or_key, i18n_options)
+end
+
+describe "Localization Adapter" do
+  before do
+    I18n.backend.store_translations(
+      :en,
+      :tests_localization_invocation_options_action =>
+      {
+        :light_service => {
+          :failures => {
+            :some_failure_reason => "This has failed",
+            :failure_with_interpolation => "Failed with %{reason}"
+          },
+          :successes => {
+            :some_success_reason => "This has passed",
+            :success_with_interpolation => "Passed with %{reason}"
+          }
+        }
+      }
+    )
+  end
+
+  describe "passing a simple string message" do
+    describe "by failing the context" do
+      it "returns the string" do
+        result = fail_with("string message")
+
+        expect(result).to be_failure
+        expect(result.message).to eq("string message")
+      end
+    end
+
+    describe "by passing the context" do
+      it "returns the string" do
+        result = pass_with("string message")
+
+        expect(result).to be_success
+        expect(result.message).to eq("string message")
+      end
+    end
+  end
+
+  describe "passing a Symbol" do
+    describe "by failing the context" do
+      it "performs a translation" do
+        result = fail_with(:some_failure_reason)
+
+        expect(result).to be_failure
+        expect(result.message).to eq("This has failed")
+      end
+    end
+
+    describe "by passing the contenxt" do
+      it "performs a translation" do
+        result = pass_with(:some_success_reason)
+
+        expect(result).to be_success
+        expect(result.message).to eq("This has passed")
+      end
+    end
+  end
+
+  describe "passing a Symbol with interpolation variables" do
+    describe "by failing the context" do
+      it "performs a translation with interpolation" do
+        result = fail_with(:failure_with_interpolation,
+                           :reason => "bad account")
+
+        expect(result).to be_failure
+        expect(result.message).to eq("Failed with bad account")
+      end
+    end
+
+    describe "by passing the context" do
+      it "performs a translation with interpolation" do
+        result = pass_with(:success_with_interpolation,
+                           :reason => "account in good standing")
+
+        expect(result).to be_success
+        expect(result.message).to eq("Passed with account in good standing")
+      end
+    end
+  end
+end

data/spec/acceptance/not_having_call_method_warning_spec.rb

@@ -0,0 +1,39 @@
+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
+      expect(ActiveSupport::Deprecation)
+        .to receive(:warn)
+        .with(/^The <OrganizerWithoutCallMethod> class is an organizer/)
+
+      class OrganizerWithoutCallMethod
+        extend FunctionalLightService::Organizer
+
+        def self.do_something
+          reduce([])
+        end
+      end
+
+      OrganizerWithoutCallMethod.do_something
+    end
+  end
+
+  context "when the organizer has the `call` method" do
+    it "does not issue a warning" do
+      expect(ActiveSupport::Deprecation)
+        .not_to receive(:warn)
+
+      class OrganizerWithCallMethod
+        extend FunctionalLightService::Organizer
+
+        def self.call
+          reduce([])
+        end
+      end
+
+      OrganizerWithCallMethod.call
+    end
+  end
+end

data/spec/acceptance/organizer/around_each_with_reduce_if_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe FunctionalLightService::Organizer do
+  class TestReduceIfWithAroundEach
+    extend FunctionalLightService::Organizer
+
+    def self.call(context)
+      with(context)
+        .around_each(TestDoubles::AroundEachLoggerHandler)
+        .reduce(actions)
+    end
+
+    def self.actions
+      [
+        TestDoubles::AddsOneAction,
+        reduce_if(->(ctx) { ctx.number == 1 },
+                  TestDoubles::AddsOneAction)
+      ]
+    end
+  end
+
+  it 'can be used to log data' do
+    result =
+      TestReduceIfWithAroundEach
+      .call(:number => 0,
+            :logger => TestDoubles::TestLogger.new)
+
+    expect(result.fetch(:number)).to eq(2)
+    expect(result[:logger].logs).to eq(
+      [{
+        :action => TestDoubles::AddsOneAction,
+        :before => 0,
+        :after => 1
+      }, {
+        :action => TestDoubles::AddsOneAction,
+        :before => 1,
+        :after => 2
+      }]
+    )
+  end
+end

data/spec/acceptance/organizer/context_failure_and_skipping_spec.rb

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

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