light-service 0.4.0 → 0.5.0

data/lib/light-service/organizer/with_reducer_log_decorator.rb

@@ -1,6 +1,8 @@
 module LightService; module Organizer
   class WithReducerLogDecorator
-    attr_reader :logger, :decorated, :organizer
+    attr_reader :logged, :logger, :decorated, :organizer
+
+    alias_method :logged?, :logged
 
     def initialize(decorated = WithReducer.new, organizer)
       @decorated, @organizer = decorated, organizer
@@ -19,8 +21,13 @@ module LightService; module Organizer
 
     def reduce(*actions)
       decorated.reduce(*actions) do |context, action|
-        next if has_failure?(context, action)
-        next if skip_all?(context, action)
+        next if logged?
+        if has_failure?(context)
+          write_failure_log(context, action) and next
+        end
+        if skip_all?(context)
+          write_skip_all_log(context, action) and next
+        end
 
         logger.info("[LightService] - executing <#{action.to_s}>")
         if defined? action.expects and action.expects.any?
@@ -34,29 +41,26 @@ module LightService; module Organizer
     end
 
     private
-    def logged?
-      @logged
-    end
 
     def extract_keys(keys)
       keys.map {|key| ":#{key}" }.join(', ')
     end
 
-    def has_failure?(context, action)
-      return false unless context.respond_to?(:failure?)
-      return false unless context.failure?
-      return true if logged?
+    def has_failure?(context)
+      context.respond_to?(:failure?) && context.failure?
+    end
 
+    def write_failure_log(context, action)
       logger.warn("[LightService] - :-((( <#{action.to_s}> has failed...")
       logger.warn("[LightService] - context message: #{context.message}")
       @logged = true
     end
 
-    def skip_all?(context, action)
-      return false unless context.respond_to?(:skip_all?)
-      return false unless context.skip_all?
-      return true if logged?
+    def skip_all?(context)
+      context.respond_to?(:skip_all?) && context.skip_all?
+    end
 
+    def write_skip_all_log(context, action)
       logger.info("[LightService] - ;-) <#{action.to_s}> has decided to skip the rest of the actions")
       logger.info("[LightService] - context message: #{context.message}")
       @logged = true

data/lib/light-service/version.rb

@@ -1,3 +1,3 @@
 module LightService
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/light-service.gemspec

@@ -16,6 +16,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = LightService::VERSION
 
+  gem.add_dependency("activesupport", ">= 4.0")
+
   gem.add_development_dependency("rspec", "~> 3.0")
   gem.add_development_dependency("rspec-its", "~> 1.0")
   gem.add_development_dependency("simplecov", "~> 0.7.1")

data/spec/acceptance/add_numbers_spec.rb

@@ -1,49 +1,9 @@
 require 'spec_helper'
+require 'test_doubles'
 
-class AdditionOrganizer
-  extend LightService::Organizer
-
-  def self.add_numbers(number)
-    with(:number => number).reduce(
-      AddsOneAction,
-      AddsTwoAction,
-      AddsThreeAction
-    )
-  end
-end
-
-class AddsOneAction
-  include LightService::Action
-  expects :number
-  promises :number
-
-  executed do |context|
-    context.number += 1
-  end
-end
-
-class AddsTwoAction
-  include LightService::Action
-  expects :number
-
-  executed do |context|
-    context.number += 2
-  end
-end
-
-class AddsThreeAction
-  include LightService::Action
-  expects :number
-  promises :product
-
-  executed do |context|
-    context.product = context.number + 3
-  end
-end
-
-describe AdditionOrganizer do
-  it "Adds 1 2 3 and through to 1" do
-    result = AdditionOrganizer.add_numbers 1
+describe TestDoubles::AdditionOrganizer do
+  it "Adds 1, 2 and 3 to the initial value of 1" do
+    result = TestDoubles::AdditionOrganizer.add_numbers 1
     number = result.fetch(:product)
 
     expect(number).to eq(7)

data/spec/acceptance/log_from_organizer_spec.rb

@@ -9,7 +9,7 @@ describe "Logs from organizer" do
     strio = StringIO.new
     LightService::Configuration.logger = Logger.new(strio)
 
-    result = yield
+    yield
 
     LightService::Configuration.logger = original_logger
 
@@ -90,7 +90,24 @@ describe "Logs from organizer" do
     it "logs it with a warning" do
       organizer_log_message = "WARN -- : [LightService] - :-((( <TestDoubles::MakesLatteAction> has failed..."
       expect(log_message).to include(organizer_log_message)
-      organizer_log_message = "WARN -- : [LightService] - context message: Can't make a latte from a milk that's too hot!"
+      organizer_log_message = "WARN -- : [LightService] - context message: Can't make a latte from a milk that's very hot!"
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "[LightService] -  :-((( <TestDoubles::AddsTwoAction> has failed..."
+      expect(log_message).not_to include(organizer_log_message)
+    end
+  end
+
+  context "when the context has failed with rollback" do
+    subject(:log_message) do
+      collects_log do
+        TestDoubles::MakesCappuccinoAddsTwoAndFails.call("espresso coffee", :super_hot)
+      end
+    end
+
+    it "logs it with a warning" do
+      organizer_log_message = "WARN -- : [LightService] - :-((( <TestDoubles::MakesLatteAction> has failed..."
+      expect(log_message).to include(organizer_log_message)
+      organizer_log_message = "WARN -- : [LightService] - context message: Can't make a latte from a milk that's super hot!"
       expect(log_message).to include(organizer_log_message)
       organizer_log_message = "[LightService] -  :-((( <TestDoubles::AddsTwoAction> has failed..."
       expect(log_message).not_to include(organizer_log_message)

data/spec/acceptance/message_localization_spec.rb

@@ -0,0 +1,116 @@
+require "spec_helper"
+require "test_doubles"
+
+class TestsLocalizationAdapter
+  extend LightService::Organizer
+
+  def self.with_message(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
+  include LightService::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.with_message(true, message_or_key, i18n_options)
+end
+
+def fail_with(message_or_key, i18n_options={})
+  TestsLocalizationAdapter.with_message(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/rollback_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'test_doubles'
+
+class RollbackOrganizer
+  extend LightService::Organizer
+
+  def self.for(number)
+    with(:number => number).reduce(
+      AddsOneWithRollbackAction,
+      TestDoubles::AddsTwoAction,
+      AddsThreeWithRollbackAction
+    )
+  end
+end
+
+class AddsOneWithRollbackAction
+  include LightService::Action
+  expects :number
+  promises :number
+
+  executed do |context|
+    if context.number == 0
+      context.fail_with_rollback!
+    end
+
+    context.number += 1
+  end
+
+  rolled_back do |context|
+    context.number -= 1
+  end
+end
+
+class AddsThreeWithRollbackAction
+  include LightService::Action
+  expects :number
+
+  executed do |context|
+    context.number = context.number + 3
+
+    context.fail_with_rollback!("I did not like this!")
+  end
+
+  rolled_back do |context|
+    context.number -= 3
+  end
+end
+
+class RollbackOrganizerWithNoRollback
+  extend LightService::Organizer
+
+  def self.for(number)
+    with(:number => number).reduce(
+      TestDoubles::AddsOneAction,
+      TestDoubles::AddsTwoAction,
+      AddsThreeWithNoRollbackAction
+    )
+  end
+end
+
+class AddsThreeWithNoRollbackAction
+  include LightService::Action
+  expects :number
+
+  executed do |context|
+    context.number = context.number + 3
+
+    context.fail_with_rollback!("I did not like this!")
+  end
+end
+
+class RollbackOrganizerWithMiddleRollback
+  extend LightService::Organizer
+
+  def self.for(number)
+    with(:number => number).reduce(
+      TestDoubles::AddsOneAction,
+      AddsTwoActionWithRollback,
+      TestDoubles::AddsThreeAction
+    )
+  end
+end
+
+class AddsTwoActionWithRollback
+  include LightService::Action
+  expects :number
+
+  executed do |context|
+    context.number = context.number + 2
+
+    context.fail_with_rollback!("I did not like this a bit!")
+  end
+
+  rolled_back do |context|
+    context.number -= 2
+  end
+end
+
+describe "Rolling back actions when there is a failure" do
+  it "Adds 1, 2, 3 to 1 and rolls back " do
+    result = RollbackOrganizer.for 1
+    number = result.fetch(:number)
+
+    expect(result).to be_failure
+    expect(result.message).to eq("I did not like this!")
+    expect(number).to eq(3)
+  end
+
+  it "won't error out when actions don't define rollback" do
+    result = RollbackOrganizerWithNoRollback.for 1
+    number = result.fetch(:number)
+
+    expect(result).to be_failure
+    expect(result.message).to eq("I did not like this!")
+    expect(number).to eq(7)
+  end
+
+  it "rolls back properly when triggered with an action in the middle" do
+    result = RollbackOrganizerWithMiddleRollback.for 1
+    number = result.fetch(:number)
+
+    expect(result).to be_failure
+    expect(result.message).to eq("I did not like this a bit!")
+    expect(number).to eq(2)
+  end
+
+  it "rolls back from the first action" do
+    result = RollbackOrganizer.for 0
+    number = result.fetch(:number)
+
+    expect(result).to be_failure
+    expect(number).to eq(-1)
+  end
+end

data/spec/action_promised_keys_spec.rb

@@ -5,26 +5,32 @@ describe ":promises macro" do
 
   context "when the promised key is not in the context" do
     it "raises an ArgumentError" do
-      class TestDoubles::MakesCappuccinoAction
+      class TestDoubles::MakesCappuccinoAction1
+        include LightService::Action
+        expects :coffee, :milk
+        promises :cappuccino
         executed do |context|
           context[:macchiato] = "#{context.coffee} - #{context.milk}"
         end
       end
 
-      exception_error_text = "promised :cappuccino to be in the context during TestDoubles::MakesCappuccinoAction"
+      exception_error_text = "promised :cappuccino to be in the context during TestDoubles::MakesCappuccinoAction1"
       expect {
-        TestDoubles::MakesCappuccinoAction.execute(:coffee => "espresso", :milk => "2%")
+        TestDoubles::MakesCappuccinoAction1.execute(:coffee => "espresso", :milk => "2%")
       }.to raise_error(LightService::PromisedKeysNotInContextError, exception_error_text)
     end
 
     it "can fail the context without fulfilling its promise" do
-      class TestDoubles::MakesCappuccinoAction
+      class TestDoubles::MakesCappuccinoAction2
+        include LightService::Action
+        expects :coffee, :milk
+        promises :cappuccino
         executed do |context|
           context.fail!("Sorry, something bad has happened.")
         end
       end
 
-      result_context = TestDoubles::MakesCappuccinoAction.execute(
+      result_context = TestDoubles::MakesCappuccinoAction2.execute(
                           :coffee => "espresso",
                           :milk => "2%")
 
@@ -35,14 +41,17 @@ describe ":promises macro" do
 
   context "when the promised key is in the context" do
     it "can be set with an actual value" do
-      class TestDoubles::MakesCappuccinoAction
+      class TestDoubles::MakesCappuccinoAction3
+        include LightService::Action
+        expects :coffee, :milk
+        promises :cappuccino
         executed do |context|
           context.cappuccino = "#{context.coffee} - with #{context.milk} milk"
           context.cappuccino += " hot"
         end
       end
 
-      result_context = TestDoubles::MakesCappuccinoAction.execute(
+      result_context = TestDoubles::MakesCappuccinoAction3.execute(
                           :coffee => "espresso",
                           :milk => "2%")
 
@@ -51,12 +60,15 @@ describe ":promises macro" do
     end
 
     it "can be set with nil" do
-      class TestDoubles::MakesCappuccinoAction
+      class TestDoubles::MakesCappuccinoAction4
+        include LightService::Action
+        expects :coffee, :milk
+        promises :cappuccino
         executed do |context|
           context.cappuccino = nil
         end
       end
-      result_context = TestDoubles::MakesCappuccinoAction.execute(
+      result_context = TestDoubles::MakesCappuccinoAction4.execute(
                           :coffee => "espresso",
                           :milk => "2%")