light-service 0.10.1 → 0.13.0

data/lib/light-service/version.rb

@@ -1,3 +1,3 @@
 module LightService
-  VERSION = "0.10.1".freeze
+  VERSION = "0.13.0".freeze
 end

data/light-service.gemspec

@@ -16,10 +16,11 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = LightService::VERSION
 
-  gem.add_dependency("activesupport", ">= 3.0")
+  gem.add_runtime_dependency("activesupport", ">= 3.0.0")
 
   gem.add_development_dependency("rspec", "~> 3.0")
-  gem.add_development_dependency("simplecov", "~> 0.16.1")
-  gem.add_development_dependency("rubocop", "~> 0.53")
-  gem.add_development_dependency("pry", "~> 0.10")
+  gem.add_development_dependency("simplecov", "~> 0.17")
+  gem.add_development_dependency("rubocop", "~> 0.68.0")
+  gem.add_development_dependency("rubocop-performance", "~> 1.2.0")
+  gem.add_development_dependency("pry", "~> 0.12.2")
 end

data/spec/acceptance/after_actions_spec.rb

@@ -64,4 +64,17 @@ RSpec.describe 'Action after_actions' do
       expect(result.fetch(:number)).to eq(1)
     end
   end
+
+  describe 'after_actions can be appended' do
+    it 'adds to the :_after_actions collection' do
+      TestDoubles::AdditionOrganizer.append_after_actions(
+        lambda do |ctx|
+          ctx.number -= 3 if ctx.current_action == TestDoubles::AddsThreeAction
+        end
+      )
+
+      result = TestDoubles::AdditionOrganizer.call(0)
+      expect(result.fetch(:number)).to eq(3)
+    end
+  end
 end

data/spec/acceptance/custom_log_from_organizer_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "Log from an organizer with a custom logger" do
+  context "when overriding the global LightService organizer" do
+    let(:global_logger_organizer) do
+      Class.new do
+        extend LightService::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 LightService::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 = LightService::Configuration.logger
+      LightService::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
+      LightService::Configuration.logger = @original_global_logger
+    end
+  end
+end

data/spec/acceptance/fail_spec.rb

@@ -1,24 +1,50 @@
 require 'spec_helper'
 
-RSpec.describe "fail! returns immediately from executed block" do
-  class FailAction
-    extend LightService::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
+RSpec.describe "fail_and_return!" do
+  describe "returns immediately from executed block" do
+    class FailAndReturnAction
+      extend LightService::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
 
-  it "returns immediately from executed block" do
-    result = FailAction.execute
+  describe "accepts error_code option" do
+    class FailAndReturnWithErrorCodeAction
+      extend LightService::Action
+      promises :one, :two
 
-    expect(result).to be_failure
-    expect(result.two).to be_nil
+      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/organizer/add_aliases_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+RSpec.describe LightService::Organizer do
+  class TestAddAliases
+    extend LightService::Organizer
+
+    def self.call(context = LightService::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 LightService::Organizer do
+  class TestAddToContext
+    extend LightService::Organizer
+
+    def self.call(context = LightService::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/execute_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe LightService::Organizer do
         TestDoubles::AddsOneAction,
         execute(->(ctx) { ctx.number += 1 }),
         execute(->(ctx) { ctx[:something] = 'hello' }),
-        TestDoubles::AddsOneAction
+        TestDoubles::AddsOne.actions
       ]
     end
   end

data/spec/acceptance/organizer/reduce_if_spec.rb

@@ -48,4 +48,36 @@ RSpec.describe LightService::Organizer do
     result = TestReduceIf.call(empty_context)
     expect(result).to be_success
   end
+
+  it 'skips actions within in its own scope' do
+    org = Class.new do
+      extend LightService::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

data/spec/acceptance/testing/context_factory_spec.rb

@@ -13,7 +13,7 @@ class AdditionOrganizerContextFactory
 end
 
 RSpec.describe TestDoubles::AddsThreeAction do
-  it "creates a context for the action with ContextFactory wrapper" do
+  it 'creates a context for the action with ContextFactory wrapper' do
     context =
       AdditionOrganizerContextFactory
       .make_for(TestDoubles::AddsThreeAction, 1)
@@ -21,7 +21,7 @@ RSpec.describe TestDoubles::AddsThreeAction do
     expect(context.number).to eq(7)
   end
 
-  it "creates a context for the action using the ContextFactory" do
+  it 'creates a context for the action using the ContextFactory' do
     context =
       LightService::Testing::ContextFactory
       .make_from(TestDoubles::AdditionOrganizer)
@@ -30,10 +30,19 @@ RSpec.describe TestDoubles::AddsThreeAction do
 
     expect(context.number).to eq(7)
   end
+
+  it "works with multiple arguments passed to Organizer's call method" do
+    context = LightService::Testing::ContextFactory
+              .make_from(TestDoubles::ExtraArgumentAdditionOrganizer)
+              .for(described_class)
+              .with(4, 2)
+
+    expect(context.number).to eq(9)
+  end
 end
 
 RSpec.describe TestDoubles::AddsTwoAction do
-  it "does not execute a callback entirely from a ContextFactory" do
+  it 'does not execute a callback entirely from a ContextFactory' do
     context = LightService::Testing::ContextFactory
               .make_from(TestDoubles::CallbackOrganizer)
               .for(described_class)

data/spec/organizer_spec.rb

@@ -44,20 +44,6 @@ describe LightService::Organizer do
     end
   end
 
-  context "when no starting context is specified" do
-    it "creates one implicitly" do
-      expect(TestDoubles::AnAction).to receive(:execute)
-        .with({})
-        .and_return(ctx)
-      expect(TestDoubles::AnotherAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-
-      expect { TestDoubles::AnOrganizer.do_something_with_no_starting_context }
-        .not_to raise_error
-    end
-  end
-
   context "when aliases are declared" do
     let(:organizer) do
       Class.new do
@@ -83,4 +69,41 @@ describe LightService::Organizer do
       organizer.call
     end
   end
+
+  context "when an organizer is nested and reduced within another" do
+    let(:reduced) { TestDoubles::NestingOrganizer.call(ctx) }
+    let(:organizer_result) do
+      TestDoubles::NotExplicitlyReturningContextOrganizer.call(ctx)
+    end
+
+    it "reduces an organizer which returns something" do
+      expect(organizer_result).to eq([1, 2, 3])
+    end
+
+    it "adds :foo and :bar to the context" do
+      reduced
+      expect(ctx[:foo]).to eq([1, 2, 3])
+      expect(ctx[:bar]).to eq(ctx[:foo])
+    end
+
+    it "returns the context" do
+      expect(reduced).to eq(ctx)
+    end
+  end
+
+  context 'can add items to the context' do
+    specify 'with #add_to_context' do
+      result = TestDoubles::AnOrganizerThatAddsToContext.call
+      expect(result[:strongest_avenger]).to eq 'The Thor'
+      expect(result[:last_jedi]).to eq 'Rey'
+    end
+  end
+
+  context 'can assign key aliaeses' do
+    it 'with #add_aliases' do
+      result = TestDoubles::AnOrganizerThatAddsAliases.call
+      expect(result[:foo]).to eq :bar
+      expect(result[:baz]).to eq :bar
+    end
+  end
 end

data/spec/sample/provides_free_shipping_action_spec.rb

@@ -15,7 +15,7 @@ describe ProvidesFreeShippingAction do
   end
 
   context "when the order total with tax is <= 200" do
-    specify "order gets free shipping" do
+    specify "order does not get free shipping" do
       allow(order).to receive_messages(:total_with_tax => 200)
       expect(order).not_to receive(:provide_free_shipping!)
 

data/spec/spec_helper.rb

@@ -15,8 +15,9 @@ end
 require 'light-service'
 require 'light-service/testing'
 require 'ostruct'
-require 'active_support/core_ext/string'
 require 'pry'
 require 'support'
+require 'test_doubles'
+require 'stringio'
 
 I18n.enforce_available_locales = true

data/spec/test_doubles.rb

@@ -102,6 +102,36 @@ module TestDoubles
     end
   end
 
+  class NotExplicitlyReturningContextOrganizer
+    extend LightService::Organizer
+
+    def self.call(context)
+      context[:foo] = [1, 2, 3]
+    end
+  end
+
+  class NestingOrganizer
+    extend LightService::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [NotExplicitlyReturningContextOrganizer, NestedAction]
+    end
+  end
+
+  class NestedAction
+    extend LightService::Action
+
+    expects :foo
+
+    executed do |context|
+      context[:bar] = context.foo
+    end
+  end
+
   class MakesTeaWithMilkAction
     extend LightService::Action
     expects :tea, :milk
@@ -223,6 +253,34 @@ module TestDoubles
     end
   end
 
+  class ExtraArgumentAdditionOrganizer
+    extend LightService::Organizer
+
+    def self.call(number, another_number)
+      with(:number => number + another_number).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        AddsTwoAction,
+        AddsThreeAction
+      ]
+    end
+  end
+
+  class AddsOne
+    extend LightService::Organizer
+
+    def call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [AddsOneAction]
+    end
+  end
+
   class AddsOneAction
     extend LightService::Action
     expects :number
@@ -497,4 +555,39 @@ module TestDoubles
       ctx.total += ctx.number
     end
   end
+
+  class CapitalizeMessage
+    extend LightService::Action
+    expects :a_message
+    promises :final_message
+
+    executed do |ctx|
+      ctx.final_message = ctx.a_message.upcase
+    end
+  end
+
+  class AnOrganizerThatAddsToContext
+    extend LightService::Organizer
+    def self.call
+      with.reduce(actions)
+    end
+
+    def self.actions
+      [add_to_context(
+        :strongest_avenger => 'The Thor',
+        :last_jedi => 'Rey'
+      )]
+    end
+  end
+
+  class AnOrganizerThatAddsAliases
+    extend LightService::Organizer
+    def self.call
+      with(:foo => :bar).reduce(actions)
+    end
+
+    def self.actions
+      [add_aliases(:foo => :baz)]
+    end
+  end
 end