functional-light-service 0.5.4 → 6.1.0

data/spec/action_expects_and_promises_spec.rb

@@ -1,93 +1,97 @@
-require 'spec_helper'
-
-describe ":expects and :promises macros" do
-  describe "actions are backward compatible" do
-    class FooAction
-      extend FunctionalLightService::Action
-
-      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)
-    end
-  end
-
-  context "when expected keys are not in context" do
-    class FooNoExpectedKeyAction
-      extend FunctionalLightService::Action
-      expects :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(FunctionalLightService::ExpectedKeysNotInContextError)
-    end
-  end
-
-  describe "expected keys" do
-    class FooWithReaderAction
-      extend FunctionalLightService::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)
-    end
-  end
-
-  context "when promised keys are not in context" do
-    class FooNoPromisedKeyAction
-      extend FunctionalLightService::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(FunctionalLightService::PromisedKeysNotInContextError)
-    end
-  end
-
-  describe "promised keys" do
-    class FooWithExpectsAndPromisesAction
-      extend FunctionalLightService::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)
-    end
-  end
-end
+require 'spec_helper'
+
+describe ":expects and :promises macros" do
+  describe "actions are backward compatible" do
+    class FooAction
+      extend FunctionalLightService::Action
+
+      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)
+    end
+  end
+
+  context "when expected keys are not in context" do
+    class FooNoExpectedKeyAction
+      extend FunctionalLightService::Action
+
+      expects :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(FunctionalLightService::ExpectedKeysNotInContextError)
+    end
+  end
+
+  describe "expected keys" do
+    class FooWithReaderAction
+      extend FunctionalLightService::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)
+    end
+  end
+
+  context "when promised keys are not in context" do
+    class FooNoPromisedKeyAction
+      extend FunctionalLightService::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(FunctionalLightService::PromisedKeysNotInContextError)
+    end
+  end
+
+  describe "promised keys" do
+    class FooWithExpectsAndPromisesAction
+      extend FunctionalLightService::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)
+    end
+  end
+end

data/spec/action_promised_keys_spec.rb

@@ -1,122 +1,126 @@
-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
-      module TestDoubles
-        class MakesCappuccinoAction1
-          extend FunctionalLightService::Action
-          expects :coffee, :milk
-          promises :cappuccino
-          executed do |context|
-            context[:macchiato] = "#{context.coffee} - #{context.milk}"
-          end
-        end
-      end
-
-      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(FunctionalLightService::PromisedKeysNotInContextError, exception_msg)
-    end
-
-    it "can fail the context without fulfilling its promise" do
-      module TestDoubles
-        class MakesCappuccinoAction2
-          extend FunctionalLightService::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%")
-
-      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
-      module TestDoubles
-        class MakesCappuccinoAction3
-          extend FunctionalLightService::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%")
-
-      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
-      module TestDoubles
-        class MakesCappuccinoAction4
-          extend FunctionalLightService::Action
-          expects :coffee, :milk
-          promises :cappuccino
-          executed do |context|
-            context.cappuccino = nil
-          end
-        end
-      end
-      result_context = TestDoubles::MakesCappuccinoAction4
-                       .execute(:coffee => "espresso",
-                                :milk => "2%")
-
-      expect(result_context).to be_success
-      expect(result_context[:cappuccino]).to be_nil
-    end
-  end
-
-  context "when a reserved key is listed as a promised key" do
-    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")
-      end.to \
-        raise_error(FunctionalLightService::ReservedKeysInContextError, exception_msg)
-    end
-
-    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(FunctionalLightService::ReservedKeysInContextError, exception_msg)
-    end
-  end
-
-  context "when the `promised` macro is called multiple times" do
-    it "collects promised keys " do
-      result = TestDoubles::MultiplePromisesAction \
-               .execute(:coffee => "espresso", :milk => "2%")
-
-      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
+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
+      module TestDoubles
+        class MakesCappuccinoAction1
+          extend FunctionalLightService::Action
+
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context[:macchiato] = "#{context.coffee} - #{context.milk}"
+          end
+        end
+      end
+
+      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(FunctionalLightService::PromisedKeysNotInContextError, exception_msg)
+    end
+
+    it "can fail the context without fulfilling its promise" do
+      module TestDoubles
+        class MakesCappuccinoAction2
+          extend FunctionalLightService::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%")
+
+      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
+      module TestDoubles
+        class MakesCappuccinoAction3
+          extend FunctionalLightService::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%")
+
+      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
+      module TestDoubles
+        class MakesCappuccinoAction4
+          extend FunctionalLightService::Action
+
+          expects :coffee, :milk
+          promises :cappuccino
+          executed do |context|
+            context.cappuccino = nil
+          end
+        end
+      end
+      result_context = TestDoubles::MakesCappuccinoAction4
+                       .execute(:coffee => "espresso",
+                                :milk => "2%")
+
+      expect(result_context).to be_success
+      expect(result_context[:cappuccino]).to be_nil
+    end
+  end
+
+  context "when a reserved key is listed as a promised key" do
+    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")
+      end.to \
+        raise_error(FunctionalLightService::ReservedKeysInContextError, exception_msg)
+    end
+
+    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(FunctionalLightService::ReservedKeysInContextError, exception_msg)
+    end
+  end
+
+  context "when the `promised` macro is called multiple times" do
+    it "collects promised keys " do
+      result = TestDoubles::MultiplePromisesAction
+               .execute(:coffee => "espresso", :milk => "2%")
+
+      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