light-service 0.6.0 → 0.6.1

data/spec/acceptance/message_localization_spec.rb

@@ -4,12 +4,12 @@ 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)
+  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
 
@@ -26,31 +26,30 @@ class TestsLocalizationInvocationOptionsAction
   end
 end
 
-def pass_with(message_or_key, i18n_options={})
+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={})
+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}"
+    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}"
+          :successes => {
+            :some_success_reason => "This has passed",
+            :success_with_interpolation => "Passed with %{reason}"
           }
         }
-      }
-    })
+      })
   end
 
   describe "passing a simple string message" do
@@ -96,7 +95,8 @@ describe "Localization Adapter" do
   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")
+        result = fail_with(:failure_with_interpolation,
+                           :reason => "bad account")
 
         expect(result).to be_failure
         expect(result.message).to eq("Failed with bad account")
@@ -105,12 +105,12 @@ describe "Localization Adapter" do
 
     describe "by passing the context" do
       it "performs a translation with interpolation" do
-        result = pass_with(:success_with_interpolation, :reason => "account in good standing")
+        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

@@ -19,9 +19,7 @@ class AddsOneWithRollbackAction
   promises :number
 
   executed do |context|
-    if context.number == 0
-      context.fail_with_rollback!
-    end
+    context.fail_with_rollback! if context.number == 0
 
     context.number += 1
   end

data/spec/action_expected_keys_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe ":expects macro" do
-
   context "when expected keys are in the context" do
     it "can access the keys as class methods" do
       resulting_context = TestDoubles::MakesTeaWithMilkAction.execute(
@@ -16,35 +15,49 @@ describe ":expects macro" do
 
   context "when an expected key is not in the context" do
     it "raises an LightService::ExpectedKeysNotInContextError" do
-      exception_error_text = "expected :milk to be in the context during TestDoubles::MakesTeaWithMilkAction"
-      expect {
+      exception_msg = "expected :milk to be in the context during " \
+                      "TestDoubles::MakesTeaWithMilkAction"
+      expect do
         TestDoubles::MakesTeaWithMilkAction.execute(:tea => "black")
-      }.to raise_error(LightService::ExpectedKeysNotInContextError, exception_error_text)
+      end.to \
+        raise_error(LightService::ExpectedKeysNotInContextError, exception_msg)
     end
   end
 
-  it "can collect expected keys when the `expects` macro is called multiple times" do
-    resulting_context = TestDoubles::MultipleExpectsAction.execute(
-      :tea => "black",
-      :milk => "full cream",
-      :chocolate => "dark chocolate"
-    )
-    expect(resulting_context[:milk_tea]).to eq("black - full cream - with dark chocolate")
+  context "when the `expects` macro is called multiple times" do
+    it "can collect expected keys " do
+      result = TestDoubles::MultipleExpectsAction.execute(
+        :tea => "black",
+        :milk => "full cream",
+        :chocolate => "dark chocolate"
+      )
+      expect(result[:milk_tea]).to \
+        eq("black - full cream - with dark chocolate")
+    end
   end
 
   context "when a reserved key is listed as an expected key" do
     it "raises an error indicating a reserved key is expected" do
-      exception_error_text = "promised or expected keys cannot be a reserved key: [:message]"
-      expect {
-        TestDoubles::MakesTeaExpectingReservedKey.execute(:tea => "black", :message => "no no")
-      }.to raise_error(LightService::ReservedKeysInContextError, exception_error_text)
+      exception_msg = "promised or expected keys cannot be a reserved key: " \
+                      "[:message]"
+      expect do
+        TestDoubles::MakesTeaExpectingReservedKey.execute(:tea => "black",
+                                                          :message => "no no")
+      end.to \
+        raise_error(LightService::ReservedKeysInContextError, exception_msg)
     end
 
     it "raises an error indicating that multiple reserved keys are expected" do
-      exception_error_text = "promised or expected keys cannot be a reserved key: [:message, :error_code, :current_action]"
-      expect {
-        TestDoubles::MakesTeaExpectingMultipleReservedKeys.execute(:tea => "black", :message => "no no", :error_code => 1, :current_action => "update")
-      }.to raise_error(LightService::ReservedKeysInContextError, exception_error_text)
+      exception_msg = "promised or expected keys cannot be a reserved key: " \
+                      "[:message, :error_code, :current_action]"
+      expect do
+        TestDoubles::MakesTeaExpectingMultipleReservedKeys
+          .execute(:tea => "black",
+                   :message => "no no",
+                   :error_code => 1,
+                   :current_action => "update")
+      end.to raise_error(LightService::ReservedKeysInContextError,
+                         exception_msg)
     end
   end
 end

data/spec/action_promised_keys_spec.rb

@@ -2,37 +2,43 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe ":promises macro" do
-
   context "when the promised key is not in the context" do
     it "raises an ArgumentError" do
-      class TestDoubles::MakesCappuccinoAction1
-        extend LightService::Action
-        expects :coffee, :milk
-        promises :cappuccino
-        executed do |context|
-          context[:macchiato] = "#{context.coffee} - #{context.milk}"
+      module TestDoubles
+        class MakesCappuccinoAction1
+          extend LightService::Action
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context[:macchiato] = "#{context.coffee} - #{context.milk}"
+          end
         end
       end
 
-      exception_error_text = "promised :cappuccino to be in the context during TestDoubles::MakesCappuccinoAction1"
-      expect {
-        TestDoubles::MakesCappuccinoAction1.execute(:coffee => "espresso", :milk => "2%")
-      }.to raise_error(LightService::PromisedKeysNotInContextError, exception_error_text)
+      exception_msg = "promised :cappuccino to be in the context during " \
+                      "TestDoubles::MakesCappuccinoAction1"
+      expect do
+        TestDoubles::MakesCappuccinoAction1.execute(:coffee => "espresso",
+                                                    :milk => "2%")
+      end.to \
+        raise_error(LightService::PromisedKeysNotInContextError, exception_msg)
     end
 
     it "can fail the context without fulfilling its promise" do
-      class TestDoubles::MakesCappuccinoAction2
-        extend LightService::Action
-        expects :coffee, :milk
-        promises :cappuccino
-        executed do |context|
-          context.fail!("Sorry, something bad has happened.")
+      module TestDoubles
+        class MakesCappuccinoAction2
+          extend LightService::Action
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context.fail!("Sorry, something bad has happened.")
+          end
         end
       end
 
-      result_context = TestDoubles::MakesCappuccinoAction2.execute(
-                          :coffee => "espresso",
-                          :milk => "2%")
+      result_context = TestDoubles::MakesCappuccinoAction2
+                       .execute(:coffee => "espresso",
+                                :milk => "2%")
 
       expect(result_context).to be_failure
       expect(result_context.keys).not_to include(:cappuccino)
@@ -41,36 +47,40 @@ 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::MakesCappuccinoAction3
-        extend LightService::Action
-        expects :coffee, :milk
-        promises :cappuccino
-        executed do |context|
-          context.cappuccino = "#{context.coffee} - with #{context.milk} milk"
-          context.cappuccino += " hot"
+      module TestDoubles
+        class MakesCappuccinoAction3
+          extend LightService::Action
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context.cappuccino = "#{context.coffee} - with #{context.milk} milk"
+            context.cappuccino += " hot"
+          end
         end
       end
 
-      result_context = TestDoubles::MakesCappuccinoAction3.execute(
-                          :coffee => "espresso",
-                          :milk => "2%")
+      result_context = TestDoubles::MakesCappuccinoAction3
+                       .execute(:coffee => "espresso",
+                                :milk => "2%")
 
       expect(result_context).to be_success
       expect(result_context.cappuccino).to eq("espresso - with 2% milk hot")
     end
 
     it "can be set with nil" do
-      class TestDoubles::MakesCappuccinoAction4
-        extend LightService::Action
-        expects :coffee, :milk
-        promises :cappuccino
-        executed do |context|
-          context.cappuccino = nil
+      module TestDoubles
+        class MakesCappuccinoAction4
+          extend LightService::Action
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context.cappuccino = nil
+          end
         end
       end
-      result_context = TestDoubles::MakesCappuccinoAction4.execute(
-                          :coffee => "espresso",
-                          :milk => "2%")
+      result_context = TestDoubles::MakesCappuccinoAction4
+                       .execute(:coffee => "espresso",
+                                :milk => "2%")
 
       expect(result_context).to be_success
       expect(result_context[:cappuccino]).to be_nil
@@ -78,27 +88,35 @@ describe ":promises macro" do
   end
 
   context "when a reserved key is listed as a promised key" do
-    it "raises an error indicating a reserved key has been promised" do
-      exception_error_text = "promised or expected keys cannot be a reserved key: [:message]"
-      expect {
+    it "raises error indicating a reserved key has been promised" do
+      exception_msg = "promised or expected keys cannot be a reserved key: "\
+                      "[:message]"
+      expect do
         TestDoubles::MakesTeaPromisingReservedKey.execute(:tea => "black")
-      }.to raise_error(LightService::ReservedKeysInContextError, exception_error_text)
+      end.to \
+        raise_error(LightService::ReservedKeysInContextError, exception_msg)
     end
 
-    it "raises an error indicating that multiple reserved keys have been promised" do
-      exception_error_text = "promised or expected keys cannot be a reserved key: [:message, :error_code, :current_action]"
-      expect {
-        TestDoubles::MakesTeaPromisingMultipleReservedKeys.execute(:tea => "black")
-      }.to raise_error(LightService::ReservedKeysInContextError, exception_error_text)
+    it "raises error indicating multiple reserved keys have been promised" do
+      exception_msg = "promised or expected keys cannot be a reserved key: " \
+                      "[:message, :error_code, :current_action]"
+      expect do
+        ctx = { :tea => "black" }
+        TestDoubles::MakesTeaPromisingMultipleReservedKeys.execute(ctx)
+      end.to \
+        raise_error(LightService::ReservedKeysInContextError, exception_msg)
     end
   end
 
-  it "can collect promised keys when the `promised` macro is called multiple times" do
-    resulting_context = TestDoubles::MultiplePromisesAction.execute(
-                            :coffee => "espresso",
-                            :milk => "2%")
+  context "when the `promised` macro is called multiple times" do
+    it "collects promised keys " do
+      result = TestDoubles::MultiplePromisesAction \
+               .execute(:coffee => "espresso", :milk => "2%")
 
-    expect(resulting_context.cappuccino).to eq("Cappucino needs espresso and a little milk")
-    expect(resulting_context.latte).to eq("Latte needs espresso and a lot of milk")
+      expect(result.cappuccino).to \
+        eq("Cappucino needs espresso and a little milk")
+      expect(result.latte).to \
+        eq("Latte needs espresso and a lot of milk")
+    end
   end
 end

data/spec/action_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe LightService::Action do
-
   let(:context) { LightService::Context.make }
 
   context "when the action context has failure" do
@@ -13,6 +12,24 @@ describe LightService::Action do
 
       expect(context.to_hash.keys).to be_empty
     end
+
+    it "returns the failure message in the context" do
+      context.fail!("an error")
+
+      returned_context = TestDoubles::AddsTwoActionWithFetch.execute(context)
+
+      expect(returned_context.message).to eq("an error")
+    end
+  end
+
+  context "when the action has an explicit success message" do
+    it "returns the success message in the context" do
+      context.succeed!("successful")
+
+      returned_context = TestDoubles::AddsTwoActionWithFetch.execute(context)
+
+      expect(returned_context.message).to eq("successful")
+    end
   end
 
   context "when the action context does not have failure" do
@@ -35,25 +52,26 @@ describe LightService::Action do
 
     it "does not execute skipped actions" do
       TestDoubles::AddsTwoActionWithFetch.execute(context)
-      expect(context.to_hash).to eq ({:number => 2})
+      expect(context.to_hash).to eq(:number => 2)
 
       context.skip_all!
 
       TestDoubles::AddsTwoActionWithFetch.execute(context)
       # Since the action was skipped, the number remains 2
-      expect(context.to_hash).to eq ({:number => 2})
+      expect(context.to_hash).to eq(:number => 2)
     end
   end
 
   it "returns the context" do
     result = TestDoubles::AddsTwoActionWithFetch.execute(context)
 
-    expect(result.to_hash).to eq ({:number => 2})
+    expect(result.to_hash).to eq(:number => 2)
   end
 
   context "when invoked with hash" do
     it "creates LightService::Context implicitly" do
-      result = TestDoubles::AddsTwoActionWithFetch.execute(:some_key => "some value")
+      ctx = { :some_key => "some value" }
+      result = TestDoubles::AddsTwoActionWithFetch.execute(ctx)
 
       expect(result).to be_success
       expect(result.keys).to eq([:some_key, :number])

data/spec/context_spec.rb

@@ -2,14 +2,15 @@ require "spec_helper"
 require 'test_doubles'
 
 describe LightService::Context do
-
   let(:context) { LightService::Context.make }
 
   describe "can be made" do
     context "with no arguments" do
       subject { LightService::Context.make }
       it { is_expected.to be_success }
-      its(:message) { should be_empty }
+      specify "message is empty string" do
+        expect(context.message).to be_empty
+      end
     end
 
     context "with a hash" do
@@ -22,7 +23,9 @@ describe LightService::Context do
 
     context "with FAILURE" do
       it "is failed" do
-        context = LightService::Context.new({}, ::LightService::Outcomes::FAILURE, '')
+        context = LightService::Context.new({},
+                                            LightService::Outcomes::FAILURE,
+                                            '')
 
         expect(context).to be_failure
       end
@@ -31,18 +34,18 @@ describe LightService::Context do
 
   describe "can't be made" do
     specify "with invalid parameters" do
-      expect{LightService::Context.make([])}.to raise_error(ArgumentError)
+      expect { LightService::Context.make([]) }.to raise_error(ArgumentError)
     end
   end
 
   it "can be asked for success?" do
-    context = LightService::Context.new({}, ::LightService::Outcomes::SUCCESS)
+    context = LightService::Context.new({}, LightService::Outcomes::SUCCESS)
 
     expect(context).to be_success
   end
 
   it "can be asked for failure?" do
-    context = LightService::Context.new({}, ::LightService::Outcomes::FAILURE)
+    context = LightService::Context.new({}, LightService::Outcomes::FAILURE)
 
     expect(context).to be_failure
   end
@@ -87,19 +90,20 @@ describe LightService::Context do
     expect(context.error_code).to be_nil
   end
 
-  it "can be pushed into a FAILURE state with an error code in an options hash" do
-    context.fail!("a sad end", 10005)
+  it "can be pushed into a FAILURE state with an error code in options hash" do
+    context.fail!("a sad end", 10_005)
 
     expect(context).to be_failure
     expect(context.message).to eq("a sad end")
-    expect(context.error_code).to eq(10005)
+    expect(context.error_code).to eq(10_005)
   end
 
   it "uses localization adapter to translate failure message" do
     action_class = TestDoubles::AnAction
-    expect(LightService::Configuration.localization_adapter).to receive(:failure)
-                                                 .with(:failure_reason, action_class, {})
-                                                 .and_return("message")
+    expect(LightService::Configuration.localization_adapter)
+      .to receive(:failure)
+      .with(:failure_reason, action_class, {})
+      .and_return("message")
 
     context = LightService::Context.make
     context.current_action = action_class
@@ -111,9 +115,10 @@ describe LightService::Context do
 
   it "uses localization adapter to translate success message" do
     action_class = TestDoubles::AnAction
-    expect(LightService::Configuration.localization_adapter).to receive(:success)
-                                                 .with(:action_passed, action_class, {})
-                                                 .and_return("message")
+    expect(LightService::Configuration.localization_adapter)
+      .to receive(:success)
+      .with(:action_passed, action_class, {})
+      .and_return("message")
 
     context = LightService::Context.make
     context.current_action = action_class
@@ -156,7 +161,7 @@ describe LightService::Context do
     let(:context) do
       LightService::Context.make(
         :foo => "foobar",
-        :_aliases => aliases,
+        :_aliases => aliases
       )
     end
     let(:aliases) { { :foo => :bar } }
@@ -171,5 +176,4 @@ describe LightService::Context do
       expect(context.fetch(:bar)).to eq context[:foo]
     end
   end
-
 end