functional-light-service 6.2.0 → 6.3.0

data/spec/acceptance/custom_log_from_organizer_spec.rb

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

@@ -1,82 +0,0 @@
-require 'spec_helper'
-# Maybe()/Null e il monkey-patch di Object sono opt-in: non fanno parte
-# del require chain di default della gem
-require 'functional-light-service/functional/maybe'
-
-describe "deprecation warnings" do
-  around do |example|
-    FunctionalLightService::Deprecations.silenced = false
-    FunctionalLightService::Deprecations.reset!
-    example.run
-  ensure
-    FunctionalLightService::Deprecations.silenced = true
-    FunctionalLightService::Deprecations.reset!
-  end
-
-  context "when including FunctionalLightService::Organizer" do
-    it "warns on stderr" do
-      expect do
-        class OrganizerIncludingLS
-          include FunctionalLightService::Organizer
-        end
-      end.to output(/Including FunctionalLightService::Organizer is deprecated/).to_stderr
-    end
-  end
-
-  context "when including FunctionalLightService::Action" do
-    it "warns on stderr" do
-      expect do
-        class ActionIncludingLS
-          include FunctionalLightService::Action
-        end
-      end.to output(/Including FunctionalLightService::Action is deprecated/).to_stderr
-    end
-  end
-
-  context "when using Maybe/Null" do
-    it "warns once per process" do
-      expect { Maybe(nil) }
-        .to output(%r{Maybe\(\)/Null are deprecated}).to_stderr
-      # warn-once: la seconda invocazione non emette nulla
-      expect { Maybe(nil) }.not_to output.to_stderr
-    end
-  end
-
-  context "when using the exotic operators" do
-    include FunctionalLightService::Prelude::Result
-
-    it "Result#>= warns and delegates to #try" do
-      result = nil
-      expect { result = Success(1) >= ->(v) { Success(v + 1) } }
-        .to output(/Result#>= is deprecated/).to_stderr
-      expect(result).to eq(Success(2))
-    end
-
-    it "Result#<< warns and delegates to #pipe" do
-      expect { Success(1) << ->(_v) {} }
-        .to output(/Result#<< is deprecated/).to_stderr
-    end
-
-    it "Result#+ warns and still combines" do
-      result = nil
-      expect { result = Success(1) + Success(2) }
-        .to output(/Result#\+ is deprecated/).to_stderr
-      expect(result).to eq(Success(3))
-    end
-
-    it "Option#+ warns and still combines" do
-      some = FunctionalLightService::Option::Some
-      result = nil
-      expect { result = some.new(1) + some.new(2) }
-        .to output(/Option#\+ is deprecated/).to_stderr
-      expect(result).to eq(some.new(3))
-    end
-  end
-
-  context "when silenced" do
-    it "emits nothing" do
-      FunctionalLightService::Deprecations.silenced = true
-      expect { Maybe(nil) }.not_to output.to_stderr
-    end
-  end
-end

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,54 +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
-
-  it "defines accessors for the added keys" do
-    result = TestAddToContext.call
-
-    expect(result.something).to eq("hello")
-  end
-
-  it "raises when the added key conflicts with a Context method" do
-    organizer = Class.new do
-      extend FunctionalLightService::Organizer
-
-      def self.call
-        reduce(steps)
-      end
-
-      def self.steps
-        [add_to_context(:message => "boom")]
-      end
-    end
-
-    expect { organizer.call }
-      .to raise_error(FunctionalLightService::ReservedKeysInContextError,
-                      /:message conflicts/)
-  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,90 +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 TestSkipAllFromNestedScope
-    extend FunctionalLightService::Organizer
-
-    def self.call
-      with(:number => 1)
-        .reduce([
-                  reduce_if(->(_ctx) { true }, [
-                              TestDoubles::AddsOneAction,
-                              execute(lambda(&:skip_all_remaining!))
-                            ]),
-                  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 'does not reset skip_all_remaining at the end of a nested scope' do
-    result = TestSkipAllFromNestedScope.call
-
-    expect(result).to be_success
-    expect(result[:number]).to eq(2)
-  end
-
-  it 'respects failure across all nestings' do
-    result = TestContextFailure.call
-
-    expect(result).to be_failure
-    expect(result[:number]).to eq(1)
-  end
-end