light-service 0.8.4 → 0.10.0

data/spec/acceptance/organizer/execute_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  class TestExecute
+    extend LightService::Organizer
+
+    def self.call(context)
+      with(context).reduce(steps)
+    end
+
+    def self.steps
+      [
+        TestDoubles::AddsOneAction,
+        execute(->(ctx) { ctx.number += 1 }),
+        execute(->(ctx) { ctx[:something] = 'hello' }),
+        TestDoubles::AddsOneAction
+      ]
+    end
+  end
+
+  let(:empty_context) { LightService::Context.make }
+
+  it 'calls the lambda in the execute block using the context' do
+    result = TestExecute.call(:number => 0)
+
+    expect(result).to be_success
+    expect(result.number).to eq(3)
+    expect(result[:something]).to eq('hello')
+  end
+
+  it 'will not execute a failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestExecute.call(empty_context)
+
+    expect(result).to be_failure
+  end
+
+  it 'does not execute over a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestExecute.call(empty_context)
+    expect(result).to be_success
+  end
+end

data/spec/acceptance/organizer/iterate_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  let(:empty_context) { LightService::Context.make }
+
+  it 'reduces each item of a collection and singularizes the collection key' do
+    result = TestDoubles::TestIterate.call(:number => 1,
+                                           :counters => [1, 2, 3, 4])
+
+    expect(result).to be_success
+    expect(result.number).to eq(5)
+  end
+
+  it 'accepts a single action or organizer' do
+    result = TestDoubles::TestIterate.call_single(:number => 1,
+                                                  :counters => [1, 2, 3, 4])
+
+    expect(result).to be_success
+    expect(result.number).to eq(5)
+  end
+
+  it 'will not iterate over a failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestDoubles::TestIterate.call(empty_context)
+
+    expect(result).to be_failure
+  end
+
+  it 'does not iterate over a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestDoubles::TestIterate.call(empty_context)
+    expect(result).to be_success
+  end
+end

data/spec/acceptance/organizer/reduce_if_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  class TestReduceIf
+    extend LightService::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) { LightService::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
+end

data/spec/acceptance/organizer/reduce_until_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  class TestReduceUntil
+    extend LightService::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        reduce_until(->(ctx) { ctx.number == 3 },
+                     TestDoubles::AddsOneAction)
+      ]
+    end
+  end
+
+  let(:empty_context) { LightService::Context.make }
+
+  it 'reduces until the block evaluates to true' do
+    context = { :number => 1 }
+    result = TestReduceUntil.call(context)
+
+    expect(result).to be_success
+    expect(result.number).to eq(3)
+  end
+
+  it 'does not execute on failed context' do
+    empty_context.fail!('Something bad happened')
+
+    result = TestReduceUntil.call(empty_context)
+    expect(result).to be_failure
+  end
+
+  it 'does not execute a skipped context' do
+    empty_context.skip_remaining!('No more needed')
+
+    result = TestReduceUntil.call(empty_context)
+    expect(result).to be_success
+  end
+end

data/spec/acceptance/organizer/with_callback_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  describe 'a simple case with a single callback' do
+    it 'calls the actions defined with callback' do
+      result = TestDoubles::TestWithCallback.call
+
+      expect(result.counter).to eq(3)
+      expect(result.total).to eq(6)
+    end
+  end
+
+  describe 'a more complex example with nested callbacks' do
+    class TestWithNestedCallback
+      extend LightService::Organizer
+
+      def self.call(context = {})
+        with(context).reduce(actions)
+      end
+
+      def self.actions
+        [
+          SetUpNestedContextAction,
+          with_callback(IterateOuterCollectionAction,
+                        [IncrementOuterCountAction,
+                         with_callback(TestDoubles::IterateCollectionAction,
+                                       [TestDoubles::IncrementCountAction,
+                                        TestDoubles::AddToTotalAction])])
+        ]
+      end
+    end
+
+    class SetUpNestedContextAction
+      extend LightService::Action
+      promises :outer_numbers, :outer_counter,
+               :numbers, :counter, :total
+
+      executed do |ctx|
+        ctx.outer_numbers = [12, 17]
+        ctx.outer_counter = 0
+        ctx.numbers = [1, 2, 3]
+        ctx.counter = 0
+        ctx.total = 0
+      end
+    end
+
+    class IterateOuterCollectionAction
+      extend LightService::Action
+      expects :outer_numbers, :callback
+      promises :outer_number
+
+      executed do |ctx|
+        ctx.outer_numbers.each do |outer_number|
+          ctx.outer_number = outer_number
+          ctx.callback.call(ctx)
+        end
+      end
+    end
+
+    class IncrementOuterCountAction
+      extend LightService::Action
+      expects :outer_counter
+
+      executed do |ctx|
+        ctx.outer_counter = ctx.outer_counter + 1
+      end
+    end
+
+    it 'calls both the action and the nested callbacks' do
+      result = TestWithNestedCallback.call
+
+      expect(result.outer_counter).to eq(2)
+      # Counts and total are the duplicates of
+      # what you'll see in the simple spec,
+      # as the internal callback logic is called
+      # twice due to 2 items in the outer_numbers
+      # collection.
+      expect(result.counter).to eq(6)
+      expect(result.total).to eq(12)
+    end
+  end
+
+  describe 'with failed or skipped context' do
+    class TestWithFailureCallback
+      extend LightService::Organizer
+
+      def self.call(context = {})
+        with(context).reduce(actions)
+      end
+
+      def self.actions
+        [
+          TestDoubles::SetUpContextAction,
+          with_callback(TestDoubles::IterateCollectionAction,
+                        [TestDoubles::IncrementCountAction,
+                         TestDoubles::FailureAction])
+        ]
+      end
+    end
+
+    it 'will not process the routine' do
+      result = TestWithFailureCallback.call
+
+      expect(result).to be_failure
+      expect(result.counter).to eq(1)
+      expect(result.total).to eq(0)
+    end
+  end
+end

data/spec/organizer/with_reducer_spec.rb

@@ -3,16 +3,13 @@ require 'test_doubles'
 
 describe LightService::Organizer::WithReducer do
   let(:context) { LightService::Context.make }
-  let(:action1) { double(:action1) }
-  let(:action2) { double(:action2) }
+  let(:action1) { TestDoubles::NullAction }
+  let(:action2) { TestDoubles::NullAction.clone }
   let(:actions) { [action1, action2] }
 
   before { context.current_action = action2 }
 
   it "reduces the provided actions" do
-    expect(action1).to receive(:execute).with(context).and_return(context)
-    expect(action2).to receive(:execute).with(context).and_return(context)
-
     result = described_class.new.with(context).reduce(actions)
 
     expect(result).to eq(context)
@@ -21,8 +18,6 @@ describe LightService::Organizer::WithReducer do
 
   it "executes a handler around each action and continues reducing" do
     expect(action1).to receive(:execute).with(context).and_return(context)
-    expect(TestDoubles::AroundEachNullHandler).to receive(:call)
-      .with(context).and_yield
 
     result = described_class.new.with(context)
                             .around_each(TestDoubles::AroundEachNullHandler)

data/spec/sample/calculates_tax_spec.rb

@@ -6,10 +6,7 @@ require_relative 'tax/provides_free_shipping_action'
 
 describe CalculatesTax do
   let(:order) { double('order') }
-  let(:ctx) do
-    double('ctx', :keys => [:user],
-                  :failure? => false, :skip_remaining? => false)
-  end
+  let(:ctx) { LightService::Context.make(:user => nil) }
 
   it "calls the actions in order" do
     allow(LightService::Context).to receive(:make)

data/spec/spec_helper.rb

@@ -1,10 +1,22 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 $LOAD_PATH << File.join(File.dirname(__FILE__))
 
+if ENV['RUN_COVERAGE_REPORT']
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter 'vendor/'
+    add_filter %r{^/spec/}
+  end
+
+  SimpleCov.minimum_coverage_by_file 90
+end
+
 require 'light-service'
 require 'light-service/testing'
 require 'ostruct'
 require 'active_support/core_ext/string'
 require 'pry'
+require 'support'
 
 I18n.enforce_available_locales = true

data/spec/support.rb

@@ -0,0 +1,9 @@
+RSpec.shared_context 'expect orchestrator warning' do
+  before do
+    expect(ActiveSupport::Deprecation)
+      .to receive(:warn)
+      .with(/^`Orchestrator#/)
+      .at_least(:once)
+  end
+end
+

data/spec/test_doubles.rb

@@ -30,26 +30,15 @@ module TestDoubles
     executed(&:fail!)
   end
 
-  class AddOneAction
-    extend LightService::Action
-    expects :number
-    promises :number
-
-    executed do |ctx|
-      ctx.number += 1
-      ctx.message = 'Added 1'
-    end
-  end
-
   class AddTwoOrganizer
     extend LightService::Organizer
     def self.call(context)
-      with(context).reduce([AddOneAction, AddOneAction])
+      with(context).reduce([AddsOneAction, AddsOneAction])
     end
   end
 
   class AroundEachNullHandler
-    def self.call(_action, _context)
+    def self.call(_action)
       yield
     end
   end
@@ -149,13 +138,11 @@ module TestDoubles
     executed do |context|
       if context.milk == :very_hot
         context.fail!("Can't make a latte from a milk that's very hot!")
-        next context
       end
 
       if context.milk == :super_hot
         error_message = "Can't make a latte from a milk that's super hot!"
         context.fail_with_rollback!(error_message)
-        next context
       end
 
       context[:latte] = "#{context.coffee} - with lots of #{context.milk}"
@@ -258,10 +245,9 @@ module TestDoubles
   class AddsThreeAction
     extend LightService::Action
     expects :number
-    promises :product
 
     executed do |context|
-      context.product = context.number + 3
+      context.number += 3
     end
   end
 
@@ -337,4 +323,85 @@ module TestDoubles
       ctx.final_key = ctx.expected_key
     end
   end
+
+  class NullAction
+    extend LightService::Action
+
+    executed { |_ctx| }
+  end
+
+  class TestIterate
+    extend LightService::Organizer
+
+    def self.call(context)
+      with(context)
+        .reduce([iterate(:counters,
+                         [TestDoubles::AddsOneAction])])
+    end
+
+    def self.call_single(context)
+      with(context)
+        .reduce([iterate(:counters,
+                         TestDoubles::AddsOneAction)])
+    end
+  end
+
+  class TestWithCallback
+    extend LightService::Organizer
+
+    def self.call(context = {})
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [
+        SetUpContextAction,
+        with_callback(IterateCollectionAction,
+                      [IncrementCountAction,
+                       AddToTotalAction])
+      ]
+    end
+  end
+
+  class SetUpContextAction
+    extend LightService::Action
+    promises :numbers, :counter, :total
+
+    executed do |ctx|
+      ctx.numbers = [1, 2, 3]
+      ctx.counter = 0
+      ctx.total = 0
+    end
+  end
+
+  class IterateCollectionAction
+    extend LightService::Action
+    expects :numbers, :callback
+    promises :number
+
+    executed do |ctx|
+      ctx.numbers.each do |number|
+        ctx.number = number
+        ctx.callback.call(ctx)
+      end
+    end
+  end
+
+  class IncrementCountAction
+    extend LightService::Action
+    expects :counter
+
+    executed do |ctx|
+      ctx.counter = ctx.counter + 1
+    end
+  end
+
+  class AddToTotalAction
+    extend LightService::Action
+    expects :number, :total
+
+    executed do |ctx|
+      ctx.total += ctx.number
+    end
+  end
 end