light-service 0.3.6 → 0.4.0

data/spec/action_expected_keys_spec.rb

@@ -1,55 +1,35 @@
 require 'spec_helper'
+require 'test_doubles'
 
-module LightService
-  describe ":expects macro" do
-    class DummyActionForKeysToExpect
-      include LightService::Action
-      expects :tea, :milk
-      promises :milk_tea
+describe ":expects macro" do
 
-      executed do |context|
-        context.milk_tea = "#{context.tea} - #{context.milk}"
-      end
-    end
-
-    context "when expected keys are in the context" do
-      it "can access the keys as class methods" do
-        resulting_context = DummyActionForKeysToExpect.execute(
-          :tea => "black",
-          :milk => "full cream",
-          :something => "else"
-        )
-        expect(resulting_context[:milk_tea]).to eq("black - full cream")
-      end
-    end
-
-    context "when an expected key is not in the context" do
-      it "raises an error" do
-        exception_error_text = "expected :milk to be in the context during LightService::DummyActionForKeysToExpect"
-        expect {
-          DummyActionForKeysToExpect.execute(:tea => "black")
-        }.to raise_error(ExpectedKeysNotInContextError, exception_error_text)
-      end
-    end
-
-    it "can collect expected keys when the `expects` macro is called multiple times" do
-      class DummyActionWithMultipleExpects
-        include LightService::Action
-        expects :tea
-        expects :milk, :chocolate
-        promises :milk_tea
-
-        executed do |context|
-          context.milk_tea = "#{context.tea} - #{context.milk} - with #{context.chocolate}"
-        end
-      end
-      resulting_context = DummyActionWithMultipleExpects.execute(
+  context "when expected keys are in the context" do
+    it "can access the keys as class methods" do
+      resulting_context = TestDoubles::MakesTeaWithMilkAction.execute(
         :tea => "black",
         :milk => "full cream",
-        :chocolate => "dark chocolate"
+        :something => "else"
       )
-      expect(resulting_context[:milk_tea]).to eq("black - full cream - with dark chocolate")
+      expect(resulting_context[:milk_tea]).to eq("black - full cream")
+    end
+  end
+
+  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 {
+        TestDoubles::MakesTeaWithMilkAction.execute(:tea => "black")
+      }.to raise_error(LightService::ExpectedKeysNotInContextError, exception_error_text)
     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")
   end
+
 end

data/spec/action_expects_and_promises_spec.rb

@@ -1,95 +1,93 @@
 require 'spec_helper'
 
-module LightService
-  describe ":expects and :promises macros" do
-    describe "actions are backward compatible" do
-      class FooAction
-        include LightService::Action
+describe ":expects and :promises macros" do
+  describe "actions are backward compatible" do
+    class FooAction
+      include LightService::Action
 
-        executed do |context|
-          baz = context.fetch :baz
+      executed do |context|
+        baz = context.fetch :baz
 
-          bar = baz + 2
-          context[:bar] = bar
-        end
-      end
-      it "works without expects and promises" do
-        result = FooAction.execute(:baz => 3)
-        expect(result).to be_success
-        expect(result[:bar]).to eq(5)
+        bar = baz + 2
+        context[:bar] = bar
       end
     end
+    it "works without expects and promises" do
+      result = FooAction.execute(:baz => 3)
+      expect(result).to be_success
+      expect(result[:bar]).to eq(5)
+    end
+  end
 
-    context "when expected keys are not in context" do
-      class FooNoExpectedKeyAction
-        include LightService::Action
-        expects :baz
+  context "when expected keys are not in context" do
+    class FooNoExpectedKeyAction
+      include LightService::Action
+      expects :baz
 
-        executed do |context|
-          baz = context.fetch :baz
+      executed do |context|
+        baz = context.fetch :baz
 
-          bar = baz + 2
-          context[:bar] = bar
-        end
-      end
-      it "throws an ExpectedKeysNotInContextError" do
-        # FooAction invoked with nothing in the context
-        expect { FooNoExpectedKeyAction.execute }.to \
-          raise_error(ExpectedKeysNotInContextError)
+        bar = baz + 2
+        context[:bar] = bar
       end
     end
+    it "throws an ExpectedKeysNotInContextError" do
+      # FooAction invoked with nothing in the context
+      expect { FooNoExpectedKeyAction.execute }.to \
+        raise_error(LightService::ExpectedKeysNotInContextError)
+    end
+  end
 
-    describe "expected keys" do
-      class FooWithReaderAction
-        include LightService::Action
-        expects :baz
+  describe "expected keys" do
+    class FooWithReaderAction
+      include LightService::Action
+      expects :baz
 
-        executed do |context|
-          # Notice how I use `context.baz` here
-          bar = context.baz + 2
-          context[:bar] = bar
-        end
-      end
-      it "can be accessed through a reader" do
-        result = FooWithReaderAction.execute(:baz => 3)
-        expect(result).to be_success
-        expect(result[:bar]).to eq(5)
+      executed do |context|
+        # Notice how I use `context.baz` here
+        bar = context.baz + 2
+        context[:bar] = bar
       end
     end
+    it "can be accessed through a reader" do
+      result = FooWithReaderAction.execute(:baz => 3)
+      expect(result).to be_success
+      expect(result[:bar]).to eq(5)
+    end
+  end
 
-    context "when promised keys are not in context" do
-      class FooNoPromisedKeyAction
-        include LightService::Action
-        expects :baz
-        promises :bar
+  context "when promised keys are not in context" do
+    class FooNoPromisedKeyAction
+      include LightService::Action
+      expects :baz
+      promises :bar
 
-        executed do |context|
-          # I am not adding anything to the context
-        end
-      end
-      it "throws a PromisedKeysNotInContextError" do
-        # FooAction invoked with nothing placed in the context
-        expect { FooNoPromisedKeyAction.execute(:baz => 3) }.to \
-          raise_error(PromisedKeysNotInContextError)
+      executed do |context|
+        # I am not adding anything to the context
       end
     end
+    it "throws a PromisedKeysNotInContextError" do
+      # FooAction invoked with nothing placed in the context
+      expect { FooNoPromisedKeyAction.execute(:baz => 3) }.to \
+        raise_error(LightService::PromisedKeysNotInContextError)
+    end
+  end
 
-    describe "promised keys" do
-      class FooWithExpectsAndPromisesAction
-        include LightService::Action
-        expects :baz
-        promises :bar
+  describe "promised keys" do
+    class FooWithExpectsAndPromisesAction
+      include LightService::Action
+      expects :baz
+      promises :bar
 
-        executed do |context|
-          # Notice how I use `context.bar` here
-          context.bar = context.baz + 2
-        end
-      end
-      it "puts the value through the accessor into the context" do
-        result = FooWithExpectsAndPromisesAction.execute(:baz => 3)
-        expect(result).to be_success
-        expect(result[:bar]).to eq(5)
+      executed do |context|
+        # Notice how I use `context.bar` here
+        context.bar = context.baz + 2
       end
     end
+    it "puts the value through the accessor into the context" do
+      result = FooWithExpectsAndPromisesAction.execute(:baz => 3)
+      expect(result).to be_success
+      expect(result[:bar]).to eq(5)
+    end
   end
 end

data/spec/action_promised_keys_spec.rb

@@ -1,88 +1,77 @@
 require 'spec_helper'
+require 'test_doubles'
 
-module LightService
-  describe ":promises macro" do
-    class DummyActionForKeysToPromise
-      include LightService::Action
-      expects :tea, :milk
-      promises :milk_tea
+describe ":promises macro" do
 
-    end
-
-    context "when the promised key is not in the context" do
-      it "raises an ArgumentError" do
-        class DummyActionForKeysToPromise
-          executed do |context|
-            context[:some_tea] = "#{context.tea} - #{context.milk}"
-          end
+  context "when the promised key is not in the context" do
+    it "raises an ArgumentError" do
+      class TestDoubles::MakesCappuccinoAction
+        executed do |context|
+          context[:macchiato] = "#{context.coffee} - #{context.milk}"
         end
-
-        exception_error_text = "promised :milk_tea to be in the context during LightService::DummyActionForKeysToPromise"
-        expect {
-          DummyActionForKeysToPromise.execute(:tea => "black", :milk => "full cream")
-        }.to raise_error(PromisedKeysNotInContextError, exception_error_text)
       end
 
-      it "can fail the context without fulfilling its promise" do
-        class DummyActionForKeysToPromise
-          executed do |context|
-            context.fail!("Sorry, something bad has happened.")
-          end
+      exception_error_text = "promised :cappuccino to be in the context during TestDoubles::MakesCappuccinoAction"
+      expect {
+        TestDoubles::MakesCappuccinoAction.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
+        executed do |context|
+          context.fail!("Sorry, something bad has happened.")
         end
+      end
 
-        result_context = DummyActionForKeysToPromise.execute(:tea => "black",
-                                                             :milk => "full cream")
+      result_context = TestDoubles::MakesCappuccinoAction.execute(
+                          :coffee => "espresso",
+                          :milk => "2%")
 
-        expect(result_context).to be_failure
-        expect(result_context.keys).not_to include(:milk_tea)
-      end
+      expect(result_context).to be_failure
+      expect(result_context.keys).not_to include(:cappuccino)
     end
+  end
 
-    context "when the promised key is in the context" do
-      it "can be set with an actual value" do
-        class DummyActionForKeysToPromise
-          executed do |context|
-            context.milk_tea = "#{context.tea} - #{context.milk}"
-            context.milk_tea += " hello"
-          end
+  context "when the promised key is in the context" do
+    it "can be set with an actual value" do
+      class TestDoubles::MakesCappuccinoAction
+        executed do |context|
+          context.cappuccino = "#{context.coffee} - with #{context.milk} milk"
+          context.cappuccino += " hot"
         end
-
-        result_context = DummyActionForKeysToPromise.execute(:tea => "black",
-                                                             :milk => "full cream")
-        expect(result_context).to be_success
-        expect(result_context[:milk_tea]).to eq("black - full cream hello")
       end
 
-      it "can be set with nil" do
-        class DummyActionForKeysToPromise
-          executed do |context|
-            context.milk_tea = nil
-          end
-        end
-        result_context = DummyActionForKeysToPromise.execute(:tea => "black",
-                                                             :milk => "full cream")
-        expect(result_context).to be_success
-        expect(result_context[:milk_tea]).to be_nil
-      end
-    end
+      result_context = TestDoubles::MakesCappuccinoAction.execute(
+                          :coffee => "espresso",
+                          :milk => "2%")
 
-    it "can collect promised keys when the `promised` macro is called multiple times" do
-      class DummyActionWithMultiplePromises
-        include LightService::Action
-        expects :coffee
-        promises :cappuccino
-        promises :latte
+      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::MakesCappuccinoAction
         executed do |context|
-          context.cappuccino = "Cappucino needs #{context.coffee} and a little milk"
-          context.latte = "Latte needs #{context.coffee} and a lot of milk"
+          context.cappuccino = nil
         end
       end
-      resulting_context = DummyActionWithMultiplePromises.execute(:coffee => "espresso")
+      result_context = TestDoubles::MakesCappuccinoAction.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_context).to be_success
+      expect(result_context[:cappuccino]).to be_nil
     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%")
+
+    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")
   end
+
 end

data/spec/action_spec.rb

@@ -1,84 +1,71 @@
 require 'spec_helper'
+require 'test_doubles'
 
-module LightService
-  describe Action do
-    class DummyAction
-      include LightService::Action
+describe LightService::Action do
 
-      executed do |context|
-        context[:test_key] = "test_value"
-      end
-    end
-
-    class SkippedAction
-      include LightService::Action
-
-      executed do |context|
-        context[:test_key] = "set_by_skipped_action"
-      end
-    end
+  let(:context) { LightService::Context.make }
 
-    let(:context) { ::LightService::Context.make }
+  context "when the action context has failure" do
+    it "returns immediately" do
+      context.fail!("an error")
 
-    context "when the action context has failure" do
-      it "returns immediately" do
-        context.fail!("an error")
+      TestDoubles::AddsTwoAction.execute(context)
 
-        DummyAction.execute(context)
-
-        expect(context.to_hash.keys).to be_empty
-      end
+      expect(context.to_hash.keys).to be_empty
     end
+  end
 
-    context "when the action context does not have failure" do
-      it "executes the block" do
-        DummyAction.execute(context)
+  context "when the action context does not have failure" do
+    it "executes the block" do
+      TestDoubles::AddsTwoAction.execute(context)
 
-        expect(context.to_hash.keys).to eq [:test_key]
-      end
+      expect(context.to_hash.keys).to eq [:number]
+      expect(context.fetch(:number)).to eq(2)
     end
+  end
 
-    context "when the action context skips all" do
-      it "returns immediately" do
-        context.skip_all!
-
-        DummyAction.execute(context)
+  context "when the action context skips all" do
+    it "returns immediately" do
+      context.skip_all!
 
-        expect(context.to_hash.keys).to be_empty
-      end
+      TestDoubles::AddsTwoAction.execute(context)
 
-      it "does not execute skipped actions" do
-        DummyAction.execute(context)
+      expect(context.to_hash.keys).to be_empty
+    end
 
-        context.skip_all!
+    it "does not execute skipped actions" do
+      TestDoubles::AddsTwoAction.execute(context)
+      expect(context.to_hash).to eq ({:number => 2})
 
-        SkippedAction.execute(context)
+      context.skip_all!
 
-        expect(context.to_hash).to eq ({:test_key => "test_value"})
-      end
+      TestDoubles::AddsTwoAction.execute(context)
+      # Since the action was skipped, the number remains 2
+      expect(context.to_hash).to eq ({:number => 2})
     end
+  end
 
-    it "returns the context" do
-      result = DummyAction.execute(context)
+  it "returns the context" do
+    result = TestDoubles::AddsTwoAction.execute(context)
 
-      expect(result.to_hash).to eq ({:test_key => "test_value"})
-    end
+    expect(result.to_hash).to eq ({:number => 2})
+  end
 
-    context "when invoked with hash" do
-      it "creates LightService::Context implicitly" do
-        result = DummyAction.execute(some_key: "some value")
+  context "when invoked with hash" do
+    it "creates LightService::Context implicitly" do
+      result = TestDoubles::AddsTwoAction.execute(:some_key => "some value")
 
-        expect(result).to be_success
-        expect(result.keys).to eq([:some_key, :test_key])
-      end
+      expect(result).to be_success
+      expect(result.keys).to eq([:some_key, :number])
     end
-    context "when invoked without arguments" do
-      it "creates LightService::Context implicitly" do
-        result = DummyAction.execute
+  end
+
+  context "when invoked without arguments" do
+    it "creates LightService::Context implicitly" do
+      result = TestDoubles::AddsTwoAction.execute
 
-        expect(result).to be_success
-        expect(result.keys).to eq([:test_key])
-      end
+      expect(result).to be_success
+      expect(result.keys).to eq([:number])
     end
   end
 end