light-service 0.6.0 → 0.6.1

data/spec/localization_adapter_spec.rb

@@ -15,18 +15,20 @@ describe LightService::LocalizationAdapter 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")
+          .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")
+          .with(message_or_key, hash_including(:i18n_variable => "value"))
+          .and_return("message")
 
-        subject = adapter.failure(message_or_key, action_class, :i18n_variable => "value")
+        subject = adapter.failure(message_or_key,
+                                  action_class,
+                                  :i18n_variable => "value")
 
         expect(subject).to eq("message")
       end
@@ -51,18 +53,20 @@ describe LightService::LocalizationAdapter 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")
+          .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")
+          .with(message_or_key, hash_including(:i18n_variable => "value"))
+          .and_return("message")
 
-        subject = adapter.success(message_or_key, action_class, :i18n_variable => "value")
+        subject = adapter.success(message_or_key,
+                                  action_class,
+                                  :i18n_variable => "value")
 
         expect(subject).to eq("message")
       end

data/spec/organizer/with_reducer_spec.rb

@@ -19,10 +19,25 @@ describe LightService::Organizer::WithReducer do
     expect(result).to be_success
   end
 
+  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(action1, context).and_yield
+
+    result = described_class.new.with(context)
+                            .around_each(TestDoubles::AroundEachNullHandler)
+                            .reduce([action1])
+
+    expect(result).to eq(context)
+    expect(result).to be_success
+  end
+
   context "when FailWithRollbackError is caught" do
     it "reduces the rollback" do
       expect(action1).to receive(:execute).with(context).and_return(context)
-      expect(action2).to receive(:execute).with(context) { raise LightService::FailWithRollbackError }
+      expect(action2).to receive(:execute).with(context) do
+        fail LightService::FailWithRollbackError
+      end
       expect(action1).to receive(:rollback).with(context).and_return(context)
       expect(action2).to receive(:rollback).with(context).and_return(context)
 
@@ -33,7 +48,9 @@ describe LightService::Organizer::WithReducer do
 
     it "reduces the rollback with an action without `rollback`" do
       expect(action1).to receive(:execute).with(context).and_return(context)
-      expect(action2).to receive(:execute).with(context) { raise LightService::FailWithRollbackError }
+      expect(action2).to receive(:execute).with(context) do
+        fail LightService::FailWithRollbackError
+      end
       expect(action2).to receive(:rollback).with(context).and_return(context)
 
       result = described_class.new.with(context).reduce(actions)

data/spec/organizer_key_aliases_spec.rb

@@ -8,11 +8,12 @@ describe "organizer aliases macro" do
 
       aliases :promised_key => :expected_key
 
-      def self.do_something(ctx={})
-        with(ctx).reduce([
-          TestDoubles::PromisesPromisedKeyAction,
-          TestDoubles::ExpectsExpectedKeyAction,
-        ])
+      def self.do_something(ctx = {})
+        with(ctx).reduce(
+          [
+            TestDoubles::PromisesPromisedKeyAction,
+            TestDoubles::ExpectsExpectedKeyAction
+          ])
       end
     end
   end

data/spec/organizer_spec.rb

@@ -2,84 +2,62 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe LightService::Organizer do
-
-  let(:context) { LightService::Context.make(:user => user) }
+  let(:ctx) { LightService::Context.make(:user => user) }
   let(:user) { double(:user) }
 
   context "when #with is called with hash" do
     before do
-      expect(TestDoubles::AnAction).to receive(:execute) \
-              .with(context) \
-              .and_return context
-      expect(TestDoubles::AnotherAction).to receive(:execute) \
-              .with(context) \
-              .and_return context
+      expect(TestDoubles::AnAction).to receive(:execute)
+        .with(ctx)
+        .and_return(ctx)
+      expect(TestDoubles::AnotherAction).to receive(:execute)
+        .with(ctx)
+        .and_return(ctx)
     end
 
     it "implicitly creates a Context" do
       result = TestDoubles::AnOrganizer.do_something(:user => user)
-      expect(result).to eq(context)
+      expect(result).to eq(ctx)
     end
   end
 
   context "when #with is called with Context" do
     before do
-      expect(TestDoubles::AnAction).to receive(:execute) \
-              .with(context) \
-              .and_return context
-      expect(TestDoubles::AnotherAction).to receive(:execute) \
-              .with(context) \
-              .and_return context
+      expect(TestDoubles::AnAction).to receive(:execute)
+        .with(ctx)
+        .and_return(ctx)
+      expect(TestDoubles::AnotherAction).to receive(:execute)
+        .with(ctx)
+        .and_return(ctx)
     end
 
     it "uses that Context without recreating it" do
-      result = TestDoubles::AnOrganizer.do_something(context)
-      expect(result).to eq(context)
+      result = TestDoubles::AnOrganizer.do_something(ctx)
+      expect(result).to eq(ctx)
     end
   end
 
   context "when no Actions are specified" do
     it "throws a Runtime error" do
-      expect { TestDoubles::AnOrganizer.do_something_with_no_actions(context) }.to \
-        raise_error RuntimeError, "No action(s) were provided"
+      expect { TestDoubles::AnOrganizer.do_something_with_no_actions(ctx) }.to \
+        raise_error(RuntimeError, "No action(s) were provided")
     end
   end
 
   context "when no starting context is specified" do
     it "creates one implicitly" do
-      expect(TestDoubles::AnAction).to receive(:execute) \
-        .with({}) \
-        .and_return(context)
-      expect(TestDoubles::AnotherAction).to receive(:execute) \
-        .with(context) \
-        .and_return(context)
-
-      expect { TestDoubles::AnOrganizer.do_something_with_no_starting_context } \
+      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 the organizer is also an action", "and the organizer rescues exceptions of its sub-actions" do
-    let(:organizer) do
-      Class.new do
-        extend LightService::Organizer
-        extend LightService::Action
-
-        executed do |ctx|
-          begin
-            with(ctx).
-              reduce(TestDoubles::MakesTeaPromisingKeyButRaisesException)
-          rescue
-          end
-        end
-      end
-    end
-
-    it "does not raise an error concerning a sub-action's missing keys" do
-      expect { organizer.execute }.not_to raise_error
-    end
-  end
-
   context "when aliases are declared" do
     let(:organizer) do
       Class.new do
@@ -93,18 +71,16 @@ describe LightService::Organizer do
     end
 
     it "merges the aliases into the data" do
-      with_reducer = double(reduce: true)
+      with_reducer = double(:reduce => true)
 
-      allow(described_class::WithReducerFactory).to receive(:make).
-        and_return(with_reducer)
+      allow(described_class::WithReducerFactory).to receive(:make)
+        .and_return(with_reducer)
 
-      expect(with_reducer).to \
-        receive(:with).
-        with(hash_including(:_aliases => { :foo => :bar })).
-        and_return(with_reducer)
+      expect(with_reducer).to receive(:with)
+        .with(hash_including(:_aliases => { :foo => :bar }))
+        .and_return(with_reducer)
 
       organizer.do_stuff
     end
   end
-
 end

data/spec/sample/calculates_tax_spec.rb

@@ -6,20 +6,28 @@ require_relative 'tax/provides_free_shipping_action'
 
 describe CalculatesTax do
   let(:order) { double('order') }
-  let(:context) { double('context', :keys => [:user],
-                         :failure? => false, :skip_all? => false) }
+  let(:ctx) do
+    double('ctx', :keys => [:user],
+                  :failure? => false, :skip_all? => false)
+  end
 
   it "calls the actions in order" do
-    allow(::LightService::Context).to receive(:make) \
-                            .with(:order => order) \
-                            .and_return context
+    allow(LightService::Context).to receive(:make)
+      .with(:order => order)
+      .and_return(ctx)
 
-    allow(LooksUpTaxPercentageAction).to receive(:execute).with(context).and_return context
-    allow(CalculatesOrderTaxAction).to receive(:execute).with(context).and_return context
-    allow(ProvidesFreeShippingAction).to receive(:execute).with(context).and_return context
+    allow(LooksUpTaxPercentageAction).to receive(:execute)
+      .with(ctx)
+      .and_return(ctx)
+    allow(CalculatesOrderTaxAction).to receive(:execute)
+      .with(ctx)
+      .and_return(ctx)
+    allow(ProvidesFreeShippingAction).to receive(:execute)
+      .with(ctx)
+      .and_return(ctx)
 
     result = CalculatesTax.for_order(order)
 
-    expect(result).to eq context
+    expect(result).to eq(ctx)
   end
 end

data/spec/sample/provides_free_shipping_action_spec.rb

@@ -3,17 +3,14 @@ require_relative 'tax/provides_free_shipping_action'
 
 describe ProvidesFreeShippingAction do
   let(:order) { double('order') }
-  let(:context) do
-    data = { :order => order }
-    ::LightService::Context.make(data)
-  end
+  let(:ctx) { { :order => order } }
 
   context "when the order total with tax is > 200" do
     specify "order gets free shipping" do
       allow(order).to receive_messages(:total_with_tax => 201)
       expect(order).to receive(:provide_free_shipping!)
 
-      ProvidesFreeShippingAction.execute(context)
+      ProvidesFreeShippingAction.execute(ctx)
     end
   end
 
@@ -22,8 +19,7 @@ describe ProvidesFreeShippingAction do
       allow(order).to receive_messages(:total_with_tax => 200)
       expect(order).not_to receive(:provide_free_shipping!)
 
-      ProvidesFreeShippingAction.execute(context)
+      ProvidesFreeShippingAction.execute(ctx)
     end
   end
-
 end

data/spec/sample/tax/calculates_order_tax_action.rb

@@ -2,7 +2,8 @@ class CalculatesOrderTaxAction
   extend ::LightService::Action
   expects :order, :tax_percentage
 
-  executed do |context|
-    context.order.tax = (context.order.total * (context.tax_percentage/100)).round(2)
+  executed do |ctx|
+    order_total = (ctx.order.total * (ctx.tax_percentage / 100))
+    ctx.order.tax = order_total.round(2)
   end
 end

data/spec/sample/tax/calculates_tax.rb

@@ -3,10 +3,9 @@ class CalculatesTax
 
   def self.for_order(order)
     with(:order => order).reduce(
-        LooksUpTaxPercentageAction,
-        CalculatesOrderTaxAction,
-        ProvidesFreeShippingAction
+      LooksUpTaxPercentageAction,
+      CalculatesOrderTaxAction,
+      ProvidesFreeShippingAction
     )
   end
 end
-  

data/spec/sample/tax/looks_up_tax_percentage_action.rb

@@ -3,23 +3,25 @@ class LooksUpTaxPercentageAction
   expects :order
   promises :tax_percentage
 
-  executed do |context|
-    tax_ranges = TaxRange.for_region(context.order.region)
-    context.tax_percentage = 0
+  executed do |ctx|
+    tax_ranges = TaxRange.for_region(ctx.order.region)
+    ctx.tax_percentage = 0
 
-    next context if object_is_nil?(tax_ranges, context, 'The tax ranges were not found')
+    next ctx if object_is_nil?(tax_ranges, ctx, 'The tax ranges were not found')
 
-    context.tax_percentage = tax_ranges.for_total(context.order.total)
+    ctx.tax_percentage = tax_ranges.for_total(ctx.order.total)
 
-    next context if object_is_nil?(context.tax_percentage, context, 'The tax percentage was not found')
+    error_message = 'The tax percentage was not found'
+    next ctx if object_is_nil?(ctx.tax_percentage, ctx, error_message)
   end
 
-  def self.object_is_nil?(object, context, message)
+  def self.object_is_nil?(object, ctx, message)
     if object.nil?
-      context.fail!(message)
+      ctx.fail!(message)
       return true
     end
 
     false
   end
+  private_class_method :object_is_nil?
 end

data/spec/sample/tax/provides_free_shipping_action.rb

@@ -4,9 +4,7 @@ class ProvidesFreeShippingAction
 
   executed do |context|
     order = context.order
-    if order.total_with_tax > 200
-      order.provide_free_shipping!
-    end
-  end
 
+    order.provide_free_shipping! if order.total_with_tax > 200
+  end
 end

data/spec/spec_helper.rb

@@ -3,7 +3,6 @@ $LOAD_PATH << File.join(File.dirname(__FILE__))
 
 require 'light-service'
 require 'ostruct'
-require 'rspec/its'
 require 'active_support/core_ext/string'
 require 'pry'
 

data/spec/test_doubles.rb

@@ -1,6 +1,31 @@
 # A collection of Action and Organizer dummies used in specs
 
 module TestDoubles
+  class AroundEachNullHandler
+    def self.call(_action, _context)
+      yield
+    end
+  end
+
+  class AroundEachLoggerHandler
+    def self.call(action, context)
+      MyLogger.info(action, context)
+      result = yield
+      MyLogger.info(action, context)
+
+      result
+    end
+  end
+
+  class AroundEachOrganizer
+    extend LightService::Organizer
+    def self.add(action_arguments)
+      with(action_arguments)
+        .around_each(AroundEachLoggerHandler)
+        .reduce([AddsTwoActionWithFetch])
+    end
+  end
+
   class AddsTwoActionWithFetch
     extend LightService::Action
 
@@ -46,7 +71,8 @@ module TestDoubles
     promises :milk_tea
 
     executed do |context|
-      context.milk_tea = "#{context.tea} - #{context.milk} - with #{context.chocolate}"
+      context.milk_tea = "#{context.tea} - #{context.milk}"\
+                         " - with #{context.chocolate}"
     end
   end
 
@@ -68,7 +94,8 @@ module TestDoubles
       end
 
       if context.milk == :super_hot
-        context.fail_with_rollback!("Can't make a latte from a milk that's 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
 
@@ -98,8 +125,8 @@ module TestDoubles
 
     def self.call(tea, milk, coffee)
       with(:tea => tea, :milk => milk, :coffee => coffee)
-          .reduce(TestDoubles::MakesTeaWithMilkAction,
-                  TestDoubles::MakesLatteAction)
+        .reduce(TestDoubles::MakesTeaWithMilkAction,
+                TestDoubles::MakesLatteAction)
     end
   end
 
@@ -108,8 +135,8 @@ module TestDoubles
 
     def self.call(milk, coffee)
       with(:milk => milk, :coffee => coffee)
-          .reduce(TestDoubles::AddsTwoActionWithFetch,
-                  TestDoubles::MakesLatteAction)
+        .reduce(TestDoubles::AddsTwoActionWithFetch,
+                TestDoubles::MakesLatteAction)
     end
   end
 
@@ -118,9 +145,8 @@ module TestDoubles
 
     def self.call(coffee, this_hot = :very_hot)
       with(:milk => this_hot, :coffee => coffee)
-          .reduce(TestDoubles::MakesLatteAction,
-                  TestDoubles::AddsTwoActionWithFetch)
-
+        .reduce(TestDoubles::MakesLatteAction,
+                TestDoubles::AddsTwoActionWithFetch)
     end
   end
 
@@ -129,9 +155,8 @@ module TestDoubles
 
     def self.call(coffee)
       with(:milk => "5%", :coffee => coffee)
-          .reduce(TestDoubles::MakesLatteAction,
-                  TestDoubles::AddsTwoActionWithFetch)
-
+        .reduce(TestDoubles::MakesLatteAction,
+                TestDoubles::AddsTwoActionWithFetch)
     end
   end
 
@@ -222,11 +247,10 @@ module TestDoubles
       context.product = make_product
     end
 
-    private
-
     def self.make_product
       fail "Fail"
     end
+    private_class_method :make_product
   end
 
   class PromisesPromisedKeyAction
@@ -249,5 +273,4 @@ module TestDoubles
       ctx.final_key = ctx.expected_key
     end
   end
-
 end