functional-light-service 6.1.0 → 6.3.0

data/spec/acceptance/fail_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe "fail_and_return!" do
-  describe "returns immediately from executed block" do
-    class FailAndReturnAction
-      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 = FailAndReturnAction.execute
-
-      expect(result).to be_failure
-      expect(result.two).to be_nil
-    end
-  end
-
-  describe "accepts error_code option" do
-    class FailAndReturnWithErrorCodeAction
-      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', :error_code => 401)
-        ctx.two = 2
-      end
-    end
-
-    it "returned context contains the error_code" do
-      result = FailAndReturnWithErrorCodeAction.execute
-
-      expect(result).to be_failure
-      expect(result.error_code).to eq 401
-      expect(result.two).to be_nil
-    end
-  end
-end

data/spec/acceptance/log_from_organizer_spec.rb

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

@@ -1,119 +0,0 @@
-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/organizer/add_aliases_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe FunctionalLightService::Organizer do
-  class TestAddAliases
-    extend FunctionalLightService::Organizer
-
-    def self.call(context = FunctionalLightService::Context.make)
-      with(context).reduce(steps)
-    end
-
-    def self.steps
-      [
-        add_to_context(:my_message => "Hello There"),
-        # This will add the alias `:a_message` which points
-        # to the :my_message key's value
-        add_aliases(:my_message => :a_message),
-        TestDoubles::CapitalizeMessage
-      ]
-    end
-  end
-
-  it "adds aliases to the context embedded in the series of actions" do
-    result = TestAddAliases.call
-
-    expect(result).to be_success
-    expect(result.final_message).to eq("HELLO THERE")
-  end
-end

data/spec/acceptance/organizer/add_to_context_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe FunctionalLightService::Organizer do
-  class TestAddToContext
-    extend FunctionalLightService::Organizer
-
-    def self.call(context = FunctionalLightService::Context.make)
-      with(context).reduce(steps)
-    end
-
-    def self.steps
-      [
-        # This will add the `:number` key to the context
-        # with the value of 0, so it's available for
-        # AddsOneAction
-        add_to_context(:number => 0),
-        TestDoubles::AddsOneAction,
-        add_to_context(:something => "hello")
-      ]
-    end
-  end
-
-  it "adds items to the context on the fly" do
-    result = TestAddToContext.call
-
-    expect(result).to be_success
-    expect(result.number).to eq(1)
-    expect(result[:something]).to eq("hello")
-  end
-end

data/spec/acceptance/organizer/around_each_with_reduce_if_spec.rb

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

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

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