light-service 0.3.6 → 0.4.0

data/spec/context_spec.rb

@@ -1,125 +1,124 @@
 require "spec_helper"
+require 'test_doubles'
 
-module LightService
-  describe Context do
+describe LightService::Context do
 
-    describe "can be made" do
-      context "with no arguments" do
-        subject { Context.make }
-        it { is_expected.to be_success }
-        its(:message) { should be_empty }
-      end
+  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 }
+    end
 
-      context "with a hash" do
-        it "has the hash values" do
-          context = Context.make(:one => 1)
+    context "with a hash" do
+      it "has the hash values" do
+        context = LightService::Context.make(:one => 1)
 
-          expect(context[:one]).to eq(1)
-        end
+        expect(context[:one]).to eq(1)
       end
+    end
 
-      context "with FAILURE" do
-        it "is failed" do
-          context = Context.new({}, ::LightService::Outcomes::FAILURE, '')
+    context "with FAILURE" do
+      it "is failed" do
+        context = LightService::Context.new({}, ::LightService::Outcomes::FAILURE, '')
 
-          expect(context).to be_failure
-        end
+        expect(context).to be_failure
       end
     end
+  end
 
-    describe "can't be made" do
-      specify "with invalid parameters" do
-        expect{Context.make([])}.to raise_error(ArgumentError)
-      end
+  describe "can't be made" do
+    specify "with invalid parameters" do
+      expect{LightService::Context.make([])}.to raise_error(ArgumentError)
     end
+  end
 
-    it "can be asked for success?" do
-      context = Context.new({}, ::LightService::Outcomes::SUCCESS)
+  it "can be asked for success?" do
+    context = LightService::Context.new({}, ::LightService::Outcomes::SUCCESS)
 
-      expect(context).to be_success
-    end
+    expect(context).to be_success
+  end
 
-    it "can be asked for failure?" do
-      context = Context.new({}, ::LightService::Outcomes::FAILURE)
+  it "can be asked for failure?" do
+    context = LightService::Context.new({}, ::LightService::Outcomes::FAILURE)
 
-      expect(context).to be_failure
-    end
-
-    it "can be asked for skip_all?" do
-      context = Context.make
-      context.skip_all!
+    expect(context).to be_failure
+  end
 
-      expect(context.skip_all?).to be_truthy
-    end
+  it "can be asked for skip_all?" do
+    context = LightService::Context.make
+    context.skip_all!
 
-    it "can be pushed into a SUCCESS state" do
-      context = Context.make
-      context.succeed!("a happy end")
+    expect(context.skip_all?).to be_truthy
+  end
 
-      expect(context).to be_success
-    end
+  it "can be pushed into a SUCCESS state" do
+    context = LightService::Context.make
+    context.succeed!("a happy end")
 
-    it "can be pushed into a SUCCESS state without a message" do
-      context = Context.make
-      context.succeed!
+    expect(context).to be_success
+  end
 
-      expect(context).to be_success
-      expect(context.message).to be_nil
-    end
+  it "can be pushed into a SUCCESS state without a message" do
+    context = LightService::Context.make
+    context.succeed!
 
-    it "can be pushed into a FAILURE state without a message" do
-      context = Context.make
-      context.fail!
+    expect(context).to be_success
+    expect(context.message).to be_nil
+  end
 
-      expect(context).to be_failure
-      expect(context.message).to be_nil
-    end
+  it "can be pushed into a FAILURE state without a message" do
+    context = LightService::Context.make
+    context.fail!
 
-    it "can be pushed into a FAILURE state with a message" do
-      context = Context.make
-      context.fail!("a sad end")
+    expect(context).to be_failure
+    expect(context.message).to be_nil
+  end
 
-      expect(context).to be_failure
-    end
+  it "can be pushed into a FAILURE state with a message" do
+    context = LightService::Context.make
+    context.fail!("a sad end")
 
-    it "can be pushed into a FAILURE state with a message in an options hash" do
-      context = Context.make
-      context.fail!("a sad end")
+    expect(context).to be_failure
+  end
 
-      expect(context).to be_failure
-      expect(context.message).to eq("a sad end")
-      expect(context.error_code).to be_nil
-    end
+  it "can be pushed into a FAILURE state with a message in an options hash" do
+    context = LightService::Context.make
+    context.fail!("a sad end")
 
-    it "can be pushed into a FAILURE state with an error code in an options hash" do
-      context = Context.make
-      context.fail!("a sad end", 10005)
+    expect(context).to be_failure
+    expect(context.message).to eq("a sad end")
+    expect(context.error_code).to be_nil
+  end
 
-      expect(context).to be_failure
-      expect(context.message).to eq("a sad end")
-      expect(context.error_code).to eq(10005)
-    end
+  it "can be pushed into a FAILURE state with an error code in an options hash" do
+    context = LightService::Context.make
+    context.fail!("a sad end", 10005)
 
-    it "can set a flag to skip all subsequent actions" do
-      context = Context.make
-      context.skip_all!
+    expect(context).to be_failure
+    expect(context.message).to eq("a sad end")
+    expect(context.error_code).to eq(10005)
+  end
 
-      expect(context).to be_skip_all
-    end
+  it "can set a flag to skip all subsequent actions" do
+    context = LightService::Context.make
+    context.skip_all!
 
-    context "stopping additional processing in an action" do
-      let(:context) { Context.make }
+    expect(context).to be_skip_all
+  end
 
-      it "flags processing to stop on failure" do
-        context.fail!("on purpose")
-        expect(context.stop_processing?).to be_truthy
-      end
+  context "stopping additional processing in an action" do
+    let(:context) { LightService::Context.make }
 
-      it "flags processing to stop when remaining actions should be skipped" do
-        context.skip_all!
-        expect(context.stop_processing?).to be_truthy
-      end
+    it "flags processing to stop on failure" do
+      context.fail!("on purpose")
+      expect(context.stop_processing?).to be_truthy
     end
 
+    it "flags processing to stop when remaining actions should be skipped" do
+      context.skip_all!
+      expect(context.stop_processing?).to be_truthy
+    end
   end
+
 end

data/spec/organizer_spec.rb

@@ -1,77 +1,60 @@
 require 'spec_helper'
+require 'test_doubles'
 
 describe LightService::Organizer do
-  class AnAction; end
-  class AnotherAction; end
 
-  class AnOrganizer
-    include LightService::Organizer
-
-    def self.do_something(action_arguments)
-      with(action_arguments).reduce([AnAction, AnotherAction])
-    end
-
-    def self.do_something_with_no_actions(action_arguments)
-      with(action_arguments).reduce
-    end
-
-    def self.do_something_with_no_starting_context
-      reduce([AnAction, AnotherAction])
-    end
-  end
-
-  let(:context) { ::LightService::Context.make(user: user) }
+  let(:context) { LightService::Context.make(:user => user) }
   let(:user) { double(:user) }
 
   context "when #with is called with hash" do
     before do
-      expect(AnAction).to receive(:execute) \
+      expect(TestDoubles::AnAction).to receive(:execute) \
               .with(context) \
               .and_return context
-      expect(AnotherAction).to receive(:execute) \
+      expect(TestDoubles::AnotherAction).to receive(:execute) \
               .with(context) \
               .and_return context
     end
 
     it "implicitly creates a Context" do
-      result = AnOrganizer.do_something(:user => user)
+      result = TestDoubles::AnOrganizer.do_something(:user => user)
       expect(result).to eq(context)
     end
   end
 
   context "when #with is called with Context" do
     before do
-      expect(AnAction).to receive(:execute) \
+      expect(TestDoubles::AnAction).to receive(:execute) \
               .with(context) \
               .and_return context
-      expect(AnotherAction).to receive(:execute) \
+      expect(TestDoubles::AnotherAction).to receive(:execute) \
               .with(context) \
               .and_return context
     end
 
     it "uses that Context without recreating it" do
-      result = AnOrganizer.do_something(context)
+      result = TestDoubles::AnOrganizer.do_something(context)
       expect(result).to eq(context)
     end
   end
 
   context "when no Actions are specified" do
     it "throws a Runtime error" do
-      expect { AnOrganizer.do_something_with_no_actions(context) }.to \
+      expect { TestDoubles::AnOrganizer.do_something_with_no_actions(context) }.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(AnAction).to receive(:execute) \
+      expect(TestDoubles::AnAction).to receive(:execute) \
         .with({}) \
         .and_return(context)
-      expect(AnotherAction).to receive(:execute) \
+      expect(TestDoubles::AnotherAction).to receive(:execute) \
         .with(context) \
         .and_return(context)
 
-      expect { AnOrganizer.do_something_with_no_starting_context } \
+      expect { TestDoubles::AnOrganizer.do_something_with_no_starting_context } \
         .not_to raise_error
     end
   end

data/spec/sample/calculates_tax_spec.rb

@@ -6,7 +6,8 @@ require_relative 'tax/provides_free_shipping_action'
 
 describe CalculatesTax do
   let(:order) { double('order') }
-  let(:context) { double('context') }
+  let(:context) { double('context', :keys => [:user],
+                         :failure? => false, :skip_all? => false) }
 
   it "calls the actions in order" do
     allow(::LightService::Context).to receive(:make) \

data/spec/test_doubles.rb

@@ -0,0 +1,132 @@
+# A collection of Action and Organizer dummies used in specs
+
+module TestDoubles
+  class AddsTwoAction
+    include LightService::Action
+
+    executed do |context|
+      number = context.fetch(:number, 0)
+      context[:number] = number + 2
+    end
+  end
+
+  class AnAction; end
+  class AnotherAction; end
+
+  class AnOrganizer
+    include LightService::Organizer
+
+    def self.do_something(action_arguments)
+      with(action_arguments).reduce([AnAction, AnotherAction])
+    end
+
+    def self.do_something_with_no_actions(action_arguments)
+      with(action_arguments).reduce
+    end
+
+    def self.do_something_with_no_starting_context
+      reduce([AnAction, AnotherAction])
+    end
+  end
+
+  class MakesTeaWithMilkAction
+    include LightService::Action
+    expects :tea, :milk
+    promises :milk_tea
+
+    executed do |context|
+      context.milk_tea = "#{context.tea} - #{context.milk}"
+    end
+  end
+
+  class MultipleExpectsAction
+    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
+
+  class MakesCappuccinoAction
+    include LightService::Action
+    expects :coffee, :milk
+    promises :cappuccino
+  end
+
+  class MakesLatteAction
+    include LightService::Action
+    expects :coffee, :milk
+    promises :latte
+
+    executed do |context|
+      if context.milk == :very_hot
+        context.fail!("Can't make a latte from a milk that's too hot!")
+        next context
+      end
+
+      context[:latte] = "#{context.coffee} - with lots of #{context.milk}"
+
+      if context.milk == "5%"
+        context.skip_all!("Can't make a latte with a fatty milk like that!")
+        next context
+      end
+    end
+  end
+
+  class MultiplePromisesAction
+    include LightService::Action
+    expects :coffee, :milk
+    promises :cappuccino
+    promises :latte
+
+    executed do |context|
+      context.cappuccino = "Cappucino needs #{context.coffee} and a little milk"
+      context.latte = "Latte needs #{context.coffee} and a lot of milk"
+    end
+  end
+
+  class MakesTeaAndCappuccino
+    include LightService::Organizer
+
+    def self.call(tea, milk, coffee)
+      with(:tea => tea, :milk => milk, :coffee => coffee)
+          .reduce(TestDoubles::MakesTeaWithMilkAction,
+                  TestDoubles::MakesLatteAction)
+    end
+  end
+
+  class MakesCappuccinoAddsTwo
+    include LightService::Organizer
+
+    def self.call(milk, coffee)
+      with(:milk => milk, :coffee => coffee)
+          .reduce(TestDoubles::AddsTwoAction,
+                  TestDoubles::MakesLatteAction)
+    end
+  end
+
+  class MakesCappuccinoAddsTwoAndFails
+    include LightService::Organizer
+
+    def self.call(coffee)
+      with(:milk => :very_hot, :coffee => coffee)
+          .reduce(TestDoubles::MakesLatteAction,
+                  TestDoubles::AddsTwoAction)
+
+    end
+  end
+
+  class MakesCappuccinoSkipsAddsTwo
+    include LightService::Organizer
+
+    def self.call(coffee)
+      with(:milk => "5%", :coffee => coffee)
+          .reduce(TestDoubles::MakesLatteAction,
+                  TestDoubles::AddsTwoAction)
+
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light-service
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.0
 platform: ruby
 authors:
 - Attila Domokos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-27 00:00:00.000000000 Z
+date: 2014-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -79,17 +79,23 @@ files:
 - Gemfile
 - LICENSE
 - README.md
+- RELEASES.md
 - Rakefile
 - lib/light-service.rb
 - lib/light-service/action.rb
+- lib/light-service/configuration.rb
 - lib/light-service/context.rb
 - lib/light-service/context_key_verifier.rb
 - lib/light-service/organizer.rb
+- lib/light-service/organizer/with_reducer.rb
+- lib/light-service/organizer/with_reducer_factory.rb
+- lib/light-service/organizer/with_reducer_log_decorator.rb
 - lib/light-service/version.rb
 - light-service.gemspec
 - resources/light-service.png
 - resources/organizer_and_actions.png
 - spec/acceptance/add_numbers_spec.rb
+- spec/acceptance/log_from_organizer_spec.rb
 - spec/action_expected_keys_spec.rb
 - spec/action_expects_and_promises_spec.rb
 - spec/action_promised_keys_spec.rb
@@ -105,6 +111,7 @@ files:
 - spec/sample/tax/looks_up_tax_percentage_action.rb
 - spec/sample/tax/provides_free_shipping_action.rb
 - spec/spec_helper.rb
+- spec/test_doubles.rb
 homepage: https://github.com/adomokos/light-service
 licenses:
 - MIT
@@ -131,6 +138,7 @@ specification_version: 4
 summary: A service skeleton with an emphasis on simplicity
 test_files:
 - spec/acceptance/add_numbers_spec.rb
+- spec/acceptance/log_from_organizer_spec.rb
 - spec/action_expected_keys_spec.rb
 - spec/action_expects_and_promises_spec.rb
 - spec/action_promised_keys_spec.rb
@@ -146,3 +154,4 @@ test_files:
 - spec/sample/tax/looks_up_tax_percentage_action.rb
 - spec/sample/tax/provides_free_shipping_action.rb
 - spec/spec_helper.rb
+- spec/test_doubles.rb