functional-light-service 0.5.4 → 6.1.0

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/context_failure_and_skipping_spec.rb

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

@@ -1,89 +1,89 @@
-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! }),
-              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
+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