light-service 0.10.2 → 0.14.0

data/spec/organizer_spec.rb

@@ -19,6 +19,11 @@ describe LightService::Organizer do
       result = TestDoubles::AnOrganizer.call(:user => user)
       expect(result).to eq(ctx)
     end
+
+    it "sets itself as the organizer" do
+      result = TestDoubles::AnOrganizer.call(:user => user)
+      expect(result.organized_by).to eq TestDoubles::AnOrganizer
+    end
   end
 
   context "when #with is called with Context" do
@@ -44,20 +49,6 @@ describe LightService::Organizer do
     end
   end
 
-  context "when no starting context is specified" do
-    it "creates one implicitly" do
-      expect(TestDoubles::AnAction).to receive(:execute)
-        .with({})
-        .and_return(ctx)
-      expect(TestDoubles::AnotherAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-
-      expect { TestDoubles::AnOrganizer.do_something_with_no_starting_context }
-        .not_to raise_error
-    end
-  end
-
   context "when aliases are declared" do
     let(:organizer) do
       Class.new do
@@ -83,4 +74,41 @@ describe LightService::Organizer do
       organizer.call
     end
   end
+
+  context "when an organizer is nested and reduced within another" do
+    let(:reduced) { TestDoubles::NestingOrganizer.call(ctx) }
+    let(:organizer_result) do
+      TestDoubles::NotExplicitlyReturningContextOrganizer.call(ctx)
+    end
+
+    it "reduces an organizer which returns something" do
+      expect(organizer_result).to eq([1, 2, 3])
+    end
+
+    it "adds :foo and :bar to the context" do
+      reduced
+      expect(ctx[:foo]).to eq([1, 2, 3])
+      expect(ctx[:bar]).to eq(ctx[:foo])
+    end
+
+    it "returns the context" do
+      expect(reduced).to eq(ctx)
+    end
+  end
+
+  context 'can add items to the context' do
+    specify 'with #add_to_context' do
+      result = TestDoubles::AnOrganizerThatAddsToContext.call
+      expect(result[:strongest_avenger]).to eq 'The Thor'
+      expect(result[:last_jedi]).to eq 'Rey'
+    end
+  end
+
+  context 'can assign key aliaeses' do
+    it 'with #add_aliases' do
+      result = TestDoubles::AnOrganizerThatAddsAliases.call
+      expect(result[:foo]).to eq :bar
+      expect(result[:baz]).to eq :bar
+    end
+  end
 end

data/spec/sample/provides_free_shipping_action_spec.rb

@@ -15,7 +15,7 @@ describe ProvidesFreeShippingAction do
   end
 
   context "when the order total with tax is <= 200" do
-    specify "order gets free shipping" do
+    specify "order does not get free shipping" do
       allow(order).to receive_messages(:total_with_tax => 200)
       expect(order).not_to receive(:provide_free_shipping!)
 

data/spec/spec_helper.rb

@@ -15,8 +15,9 @@ end
 require 'light-service'
 require 'light-service/testing'
 require 'ostruct'
-require 'active_support/core_ext/string'
 require 'pry'
 require 'support'
+require 'test_doubles'
+require 'stringio'
 
 I18n.enforce_available_locales = true

data/spec/test_doubles.rb

@@ -102,6 +102,36 @@ module TestDoubles
     end
   end
 
+  class NotExplicitlyReturningContextOrganizer
+    extend LightService::Organizer
+
+    def self.call(context)
+      context[:foo] = [1, 2, 3]
+    end
+  end
+
+  class NestingOrganizer
+    extend LightService::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [NotExplicitlyReturningContextOrganizer, NestedAction]
+    end
+  end
+
+  class NestedAction
+    extend LightService::Action
+
+    expects :foo
+
+    executed do |context|
+      context[:bar] = context.foo
+    end
+  end
+
   class MakesTeaWithMilkAction
     extend LightService::Action
     expects :tea, :milk
@@ -223,6 +253,34 @@ module TestDoubles
     end
   end
 
+  class ExtraArgumentAdditionOrganizer
+    extend LightService::Organizer
+
+    def self.call(number, another_number)
+      with(:number => number + another_number).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        AddsTwoAction,
+        AddsThreeAction
+      ]
+    end
+  end
+
+  class AddsOne
+    extend LightService::Organizer
+
+    def call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [AddsOneAction]
+    end
+  end
+
   class AddsOneAction
     extend LightService::Action
     expects :number
@@ -251,6 +309,99 @@ module TestDoubles
     end
   end
 
+  class IterateOrganizer
+    extend LightService::Organizer
+
+    def self.call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneIteratesAction,
+        iterate(:numbers, [
+                  AddsTwoAction,
+                  AddsThreeAction
+                ])
+      ]
+    end
+  end
+
+  class AddsOneIteratesAction
+    extend LightService::Action
+    expects :numbers
+    promises :numbers
+
+    executed do |context|
+      context.numbers = context.numbers.map { |n| n + 1 }
+    end
+  end
+
+  class CallbackOrganizer
+    extend LightService::Organizer
+
+    def self.call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        with_callback(AddTenCallbackAction, [
+                        AddsTwoAction,
+                        AddsThreeAction
+                      ])
+      ]
+    end
+  end
+
+  class AddTenCallbackAction
+    extend LightService::Action
+    expects :number, :callback
+
+    executed do |context|
+      context.number += 10
+      context.number =
+        context.callback.call(context).fetch(:number)
+    end
+  end
+
+  class ReduceUntilOrganizer
+    extend LightService::Organizer
+
+    def self.call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        reduce_until(->(ctx) { ctx.number > 3 }, [
+                       AddsTwoAction,
+                       AddsThreeAction
+                     ])
+      ]
+    end
+  end
+
+  class ReduceIfOrganizer
+    extend LightService::Organizer
+
+    def self.call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [
+        AddsOneAction,
+        reduce_if(->(ctx) { ctx.number > 1 }, [
+                    AddsTwoAction,
+                    AddsThreeAction
+                  ])
+      ]
+    end
+  end
+
   class MakesTeaExpectingReservedKey
     extend LightService::Action
     expects :tea, :message
@@ -404,4 +555,39 @@ module TestDoubles
       ctx.total += ctx.number
     end
   end
+
+  class CapitalizeMessage
+    extend LightService::Action
+    expects :a_message
+    promises :final_message
+
+    executed do |ctx|
+      ctx.final_message = ctx.a_message.upcase
+    end
+  end
+
+  class AnOrganizerThatAddsToContext
+    extend LightService::Organizer
+    def self.call
+      with.reduce(actions)
+    end
+
+    def self.actions
+      [add_to_context(
+        :strongest_avenger => 'The Thor',
+        :last_jedi => 'Rey'
+      )]
+    end
+  end
+
+  class AnOrganizerThatAddsAliases
+    extend LightService::Organizer
+    def self.call
+      with(:foo => :bar).reduce(actions)
+    end
+
+    def self.actions
+      [add_aliases(:foo => :baz)]
+    end
+  end
 end

data/spec/testing/context_factory/iterate_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe 'ContextFactory - used with IterateOrganizer' do
+  let(:organizer) { TestDoubles::IterateOrganizer }
+
+  context 'when called with outside iterate steps' do
+    it 'creates a context up-to the action defined before the iteration' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsOneIteratesAction)
+        .with(:numbers => [1, 2])
+
+      expect(ctx[:numbers]).to eq([1, 2])
+    end
+
+    it 'creates a context up-to iteration with empty context steps' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsTwoAction)
+        .with(:numbers => [1, 2])
+
+      expect(ctx.numbers).to eq([2, 3])
+    end
+
+    it 'creates a context only to the first step of the iteration' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsThreeAction)
+        .with(:numbers => [1, 2])
+
+      expect(ctx.numbers).to eq([2, 3])
+      expect(ctx.number).to eq(4)
+    end
+  end
+end

data/spec/testing/context_factory/reduce_if_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe 'ContextFactory - used with ReduceIfOrganizer' do
+  let(:organizer) { TestDoubles::ReduceIfOrganizer }
+
+  context 'when called with a truthy argument action' do
+    it 'executes a context up-to the callback action' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsThreeAction)
+        .with(:number => 1)
+
+      expect(ctx.number).to eq(4)
+    end
+
+    it 'creates a context up-to action with empty context steps' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsTwoAction)
+        .with(:number => 1)
+
+      expect(ctx.number).to eq(2)
+    end
+  end
+
+  context 'when called with a false argument action' do
+    it 'does not execute the steps' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsThreeAction)
+        .with(:number => 0)
+
+      expect(ctx.number).to eq(1)
+    end
+  end
+end

data/spec/testing/context_factory/reduce_until_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe 'ContextFactory - used with ReduceUntilOrganizer' do
+  let(:organizer) { TestDoubles::ReduceUntilOrganizer }
+
+  context 'when called with truthy block' do
+    it 'creates a context up-to the action defined before the iteration' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsTwoAction)
+        .with(:number => 1)
+
+      expect(ctx[:number]).to eq(2)
+    end
+
+    it 'creates a context only to the first step of the loop' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsThreeAction)
+        .with(:number => 1)
+
+      expect(ctx.number).to eq(4)
+    end
+  end
+
+  context 'when called with falsey block' do
+    it 'creates a context up-to the first step' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsThreeAction)
+        .with(:number => 7)
+
+      expect(ctx[:number]).to eq(10)
+    end
+  end
+end

data/spec/testing/context_factory/with_callback_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe 'ContextFactory - used with CallbackOrganizer' do
+  let(:organizer) { TestDoubles::CallbackOrganizer }
+
+  context 'when called with the callback action' do
+    it 'creates a context up-to the callback action' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddTenCallbackAction)
+        .with(:number => 1)
+
+      expect(ctx.number).to eq(2)
+    end
+
+    it 'creates a context up-to callback action with empty context steps' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsTwoAction)
+        .with(:number => 1)
+
+      expect(ctx.number).to eq(12)
+    end
+
+    it 'creates a context up-to the action defined in context steps' do
+      ctx =
+        LightService::Testing::ContextFactory
+        .make_from(organizer)
+        .for(TestDoubles::AddsThreeAction)
+        .with(:number => 1)
+
+      expect(ctx.number).to eq(14)
+    end
+  end
+end