functional-light-service 6.0.0 → 6.2.0

data/spec/acceptance/skip_all_remaining_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+RSpec.describe "skip_all_remaining!" do
+  context "with regular organizer" do
+    let(:organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions
+          [
+            execute(->(c) { c[:first] = true }),
+            execute(lambda(&:skip_all_remaining!)),
+            execute(->(c) { c[:second] = true })
+          ]
+        end
+      end
+    end
+
+    it "skips all remaining actions" do
+      result = organizer.call(FunctionalLightService::Context.make)
+
+      expect(result[:first]).to be true
+      expect(result[:second]).to be_nil
+    end
+  end
+
+  context "with an organizer with a reducer" do
+    let(:organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions
+          [
+            reduce_if(
+              ->(_) { true },
+              [
+                execute(->(c) { c[:first_inside] = true }),
+                execute(lambda(&:skip_all_remaining!)),
+                execute(->(c) { c[:second_inside] = true })
+              ]
+            ),
+            execute(->(c) { c[:outside] = true })
+          ]
+        end
+      end
+    end
+
+    it "skips all remaining actions inside and outside the reducer" do
+      result = organizer.call(FunctionalLightService::Context.make)
+
+      expect(result[:first_inside]).to be true
+      expect(result[:second_inside]).to be_nil
+      expect(result[:outside]).to be_nil
+    end
+  end
+
+  context "with a message" do
+    let(:organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions
+          [
+            reduce_if(
+              ->(_) { true },
+              [
+                execute(->(c) { c.skip_all_remaining!("Skipping with message") })
+              ]
+            ),
+            execute(->(c) { c[:outside] = true })
+          ]
+        end
+      end
+    end
+
+    it "preserves the message when exiting scoped reducers" do
+      result = organizer.call(FunctionalLightService::Context.make)
+
+      expect(result.message).to eq("Skipping with message")
+      expect(result[:outside]).to be_nil
+    end
+  end
+
+  context "with an organizer with nested reducers" do
+    let(:organizer) do
+      Class.new do
+        extend FunctionalLightService::Organizer
+
+        def self.call(ctx)
+          with(ctx).reduce(actions)
+        end
+
+        def self.actions # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          [
+            reduce_if(
+              ->(_) { true },
+              [
+                iterate(:items, [
+                          execute(->(c) {
+                            c[:executed_items] ||= []
+                            c[:executed_items] << c[:item]
+                          }),
+                          execute(->(c) { c.skip_all_remaining! if c[:item] == 2 }),
+                          execute(->(c) {
+                            c[:skipped_in_iterate] ||= []
+                            c[:skipped_in_iterate] << c[:item]
+                          })
+                        ]),
+                execute(->(c) { c[:after_iterate_inside_if] = true })
+              ]
+            ),
+            execute(->(c) { c[:outside] = true })
+          ]
+        end
+      end
+    end
+
+    it "skips all remaining actions across all nested scopes" do
+      result = organizer.call(FunctionalLightService::Context.make(:items => [1, 2, 3]))
+
+      expect(result[:executed_items]).to eq([1, 2])
+      expect(result[:skipped_in_iterate]).to eq([1])
+      expect(result[:after_iterate_inside_if]).to be_nil
+      expect(result[:outside]).to be_nil
+    end
+  end
+end

data/spec/action_optional_expected_keys_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe ":expects macro using defaults" do
+  context "when all expected keys are supplied" do
+    it "is expected to ignore default values" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3,
+        :second_number => 5,
+        :third_number => 7
+      )
+
+      expect(outcome.total).to eq 15
+    end
+  end
+
+  context "when defaults are supplied" do
+    it "is expected to use static values" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3,
+        :second_number => 7
+      )
+
+      expect(outcome.total).to eq 20
+    end
+
+    it "is expected to use dynamic values" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3,
+        :third_number => 5
+      )
+
+      expect(outcome.total).to eq 18
+    end
+
+    it "is expected to process defaults in their defined order" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :third_number => 5,
+        :first_number => 3
+      )
+
+      expect(outcome.total).to eq 18
+    end
+
+    it "is expected to use all defaults if required" do
+      outcome = TestDoubles::AddsNumbersWithOptionalDefaults.execute(
+        :first_number => 3
+      )
+
+      expect(outcome.total).to eq 23
+    end
+  end
+
+  context "when used within an organizer" do
+    it "is expected to process required defaults" do
+      outcome = TestDoubles::OrganizerWithActionsUsingDefaults.call
+
+      expect(outcome.total).to eq 20
+    end
+  end
+
+  context "when the expected key is satisfied through an alias" do
+    it "is expected to not apply the default" do
+      action = Class.new do
+        extend FunctionalLightService::Action
+
+        expects  :greeting, :default => "hello"
+        promises :greeted
+
+        executed do |ctx|
+          ctx.greeted = ctx.greeting
+        end
+      end
+
+      organizer = Class.new do
+        extend FunctionalLightService::Organizer
+
+        aliases :salutation => :greeting
+      end
+
+      outcome = organizer.with(:salutation => "ciao").reduce([action])
+
+      expect(outcome.greeted).to eq "ciao"
+    end
+  end
+
+  context "when defaults are misconfigured" do
+    it "is expected to raise an exception" do
+      expect do
+        # Needs to be specified in the block
+        # as error is raised at define time
+        class AddsNumbersWithIncorrectDefaults
+          extend FunctionalLightService::Action
+
+          expects  :first,  :default => 10 # This one is fine. Other two arent
+          expects  :second, :defalut => ->(ctx) { ctx[:first] + 7 }
+          expects  :third,  :deafult => 10
+          promises :total
+
+          executed do |ctx|
+            ctx.total = ctx.first + ctx.second + ctx.third
+          end
+        end
+      end.to raise_error(FunctionalLightService::UnusableExpectKeyDefaultError)
+    end
+  end
+end

data/spec/context/inspect_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe FunctionalLightService::Context do
     it 'inspects the hash with all the fields' do
       inspected_context =
         "FunctionalLightService::Context({}, success: true, message: '', error_code: nil, " \
-        "skip_remaining: false, aliases: {})"
+        "skip_remaining: false, skip_all_remaining: false, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end
@@ -24,7 +24,7 @@ RSpec.describe FunctionalLightService::Context do
 
       inspected_context =
         "FunctionalLightService::Context({}, success: false, message: 'There was an error', " \
-        "error_code: nil, skip_remaining: false, aliases: {})"
+        "error_code: nil, skip_remaining: false, skip_all_remaining: false, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end
@@ -34,7 +34,17 @@ RSpec.describe FunctionalLightService::Context do
 
       inspected_context =
         "FunctionalLightService::Context({}, success: true, message: 'No need to process', " \
-        "error_code: nil, skip_remaining: true, aliases: {})"
+        "error_code: nil, skip_remaining: true, skip_all_remaining: false, aliases: {})"
+
+      expect(context.inspect).to eq(inspected_context)
+    end
+
+    it 'prints skip_all_remaining' do
+      context.skip_all_remaining!('Nothing else to process')
+
+      inspected_context =
+        "FunctionalLightService::Context({}, success: true, message: 'Nothing else to process', " \
+        "error_code: nil, skip_remaining: false, skip_all_remaining: true, aliases: {})"
 
       expect(context.inspect).to eq(inspected_context)
     end

data/spec/context_spec.rb

@@ -198,6 +198,18 @@ RSpec.describe FunctionalLightService::Context do
       expect { action.execute(:_before_actions => []) }
         .to raise_error(FunctionalLightService::ReservedKeysInContextError)
     end
+
+    it "rejects :organized_by in expects/promises" do
+      action = Class.new do
+        extend FunctionalLightService::Action
+
+        expects :organized_by
+        executed { |_ctx| } # rubocop:disable Lint/EmptyBlock
+      end
+
+      expect { action.execute(:organized_by => Object) }
+        .to raise_error(FunctionalLightService::ReservedKeysInContextError)
+    end
   end
 
   describe "#fail! does not mutate the caller's options hash" do

data/spec/i18n_localization_adapter_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+require 'test_doubles'
+
+describe FunctionalLightService::I18n::LocalizationAdapter do
+  let(:action_class) { TestDoubles::AnAction }
+  let(:adapter) { described_class.new }
+
+  describe "#failure" do
+    subject { adapter.failure(message_or_key, action_class) }
+
+    context "when provided a Symbol" do
+      let(:message_or_key) { :not_found }
+
+      it "translates the message" do
+        expected_scope = "test_doubles/an_action.light_service.failures"
+
+        expect(I18n).to receive(:t)
+          .with(message_or_key, :scope => expected_scope)
+          .and_return("message")
+
+        expect(subject).to eq("message")
+      end
+
+      it "allows passing interpolation options to I18n layer" do
+        expect(I18n).to receive(:t)
+          .with(message_or_key, hash_including(:i18n_variable => "value"))
+          .and_return("message")
+
+        subject = adapter.failure(message_or_key,
+                                  action_class,
+                                  :i18n_variable => "value")
+
+        expect(subject).to eq("message")
+      end
+    end
+
+    context "when provided a String" do
+      let(:message_or_key) { "action failed" }
+
+      it "returns the message" do
+        expect(subject).to eq(message_or_key)
+      end
+    end
+  end
+
+  describe "#success" do
+    subject { adapter.success(message_or_key, action_class) }
+
+    context "when provided a Symbol" do
+      let(:message_or_key) { :not_found }
+
+      it "translates the message" do
+        expected_scope = "test_doubles/an_action.light_service.successes"
+
+        expect(I18n).to receive(:t)
+          .with(message_or_key, :scope => expected_scope)
+          .and_return("message")
+
+        expect(subject).to eq("message")
+      end
+
+      it "allows passing interpolation options to I18n layer" do
+        expect(I18n).to receive(:t)
+          .with(message_or_key, hash_including(:i18n_variable => "value"))
+          .and_return("message")
+
+        subject = adapter.success(message_or_key,
+                                  action_class,
+                                  :i18n_variable => "value")
+
+        expect(subject).to eq("message")
+      end
+    end
+
+    context "when provided a String" do
+      let(:message_or_key) { "action failed" }
+
+      it "returns the message" do
+        expect(subject).to eq(message_or_key)
+      end
+    end
+  end
+end