functional-light-service 0.4.4 → 6.0.0

data/spec/acceptance/custom_log_from_organizer_spec.rb

@@ -1,60 +1,61 @@
-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
+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

@@ -0,0 +1,82 @@
+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,50 +1,52 @@
-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
+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/message_localization_spec.rb

@@ -1,118 +1,119 @@
-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
+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

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

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