light-service 0.8.4 → 0.10.0

data/spec/acceptance/orchestrator/context_failure_and_skipping_spec.rb

@@ -2,24 +2,26 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe LightService::Orchestrator do
-  class TestSkipState
+  include_context 'expect orchestrator warning'
+
+  class OrchestratorTestSkipState
     extend LightService::Orchestrator
     def self.run_skip_before
       with(:number => 1).reduce([
                                   TestDoubles::SkipAllAction,
                                   reduce_until(->(ctx) { ctx.number == 3 },
-                                               TestDoubles::AddOneAction)
+                                               TestDoubles::AddsOneAction)
                                 ])
     end
 
     def self.run_skip_after
       with(:number => 1).reduce([
-                                  TestDoubles::AddOneAction,
+                                  TestDoubles::AddsOneAction,
                                   reduce_until(->(ctx) { ctx.number == 3 }, [
-                                                 TestDoubles::AddOneAction
+                                                 TestDoubles::AddsOneAction
                                                ]),
                                   TestDoubles::SkipAllAction,
-                                  TestDoubles::AddOneAction
+                                  TestDoubles::AddsOneAction
                                 ])
     end
 
@@ -27,28 +29,28 @@ describe LightService::Orchestrator do
       with(:number => 1).reduce([
                                   TestDoubles::FailureAction,
                                   reduce_until(->(ctx) { ctx[:number] == 3 },
-                                               TestDoubles::AddOneAction),
-                                  TestDoubles::AddOneAction
+                                               TestDoubles::AddsOneAction),
+                                  TestDoubles::AddsOneAction
                                 ])
     end
   end
 
   it 'skips all the rest of the actions' do
-    result = TestSkipState.run_skip_before
+    result = OrchestratorTestSkipState.run_skip_before
 
     expect(result).to be_success
     expect(result[:number]).to eq(1)
   end
 
   it 'skips after an action in nested context' do
-    result = TestSkipState.run_skip_after
+    result = OrchestratorTestSkipState.run_skip_after
 
     expect(result).to be_success
     expect(result[:number]).to eq(3)
   end
 
   it 'respects failure across all nestings' do
-    result = TestSkipState.run_failure
+    result = OrchestratorTestSkipState.run_failure
 
     expect(result).to be_failure
     expect(result[:number]).to eq(1)

data/spec/acceptance/orchestrator/execute_spec.rb

@@ -2,7 +2,9 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe LightService::Orchestrator do
-  class TestExecute
+  include_context 'expect orchestrator warning'
+
+  class OrchestratorTestExecute
     extend LightService::Orchestrator
 
     def self.run(context)
@@ -11,10 +13,10 @@ describe LightService::Orchestrator do
 
     def self.steps
       [
-        TestDoubles::AddOneAction,
+        TestDoubles::AddsOneAction,
         execute(->(ctx) { ctx.number += 1 }),
         execute(->(ctx) { ctx[:something] = 'hello' }),
-        TestDoubles::AddOneAction
+        TestDoubles::AddsOneAction
       ]
     end
   end
@@ -22,7 +24,7 @@ describe LightService::Orchestrator do
   let(:empty_context) { LightService::Context.make }
 
   it 'calls the lambda in the execute block using the context' do
-    result = TestExecute.run(:number => 0)
+    result = OrchestratorTestExecute.run(:number => 0)
 
     expect(result).to be_success
     expect(result.number).to eq(3)
@@ -32,7 +34,7 @@ describe LightService::Orchestrator do
   it 'will not execute a failed context' do
     empty_context.fail!('Something bad happened')
 
-    result = TestExecute.run(empty_context)
+    result = OrchestratorTestExecute.run(empty_context)
 
     expect(result).to be_failure
   end
@@ -40,7 +42,7 @@ describe LightService::Orchestrator do
   it 'does not execute over a skipped context' do
     empty_context.skip_remaining!('No more needed')
 
-    result = TestExecute.run(empty_context)
+    result = OrchestratorTestExecute.run(empty_context)
     expect(result).to be_success
   end
 end

data/spec/acceptance/orchestrator/iterate_spec.rb

@@ -2,20 +2,22 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe LightService::Orchestrator do
-  class TestIterate
+  include_context 'expect orchestrator warning'
+
+  class OrchestratorTestIterate
     extend LightService::Orchestrator
 
     def self.run(context)
       with(context).reduce([
                              iterate(:numbers, [
-                                       TestDoubles::AddOneAction
+                                       TestDoubles::AddsOneAction
                                      ])
                            ])
     end
 
     def self.run_single(context)
       with(context).reduce([
-                             iterate(:numbers, TestDoubles::AddOneAction)
+                             iterate(:numbers, TestDoubles::AddsOneAction)
                            ])
     end
   end
@@ -23,14 +25,14 @@ describe LightService::Orchestrator do
   let(:empty_context) { LightService::Context.make }
 
   it 'reduces each item of a collection and singularizes the collection key' do
-    result = TestIterate.run(:numbers => [1, 2, 3, 4])
+    result = OrchestratorTestIterate.run(:numbers => [1, 2, 3, 4])
 
     expect(result).to be_success
     expect(result.number).to eq(5)
   end
 
   it 'accepts a single action or organizer' do
-    result = TestIterate.run_single(:numbers => [1, 2, 3, 4])
+    result = OrchestratorTestIterate.run_single(:numbers => [1, 2, 3, 4])
 
     expect(result).to be_success
     expect(result.number).to eq(5)
@@ -39,7 +41,7 @@ describe LightService::Orchestrator do
   it 'will not iterate over a failed context' do
     empty_context.fail!('Something bad happened')
 
-    result = TestIterate.run(empty_context)
+    result = OrchestratorTestIterate.run(empty_context)
 
     expect(result).to be_failure
   end
@@ -47,7 +49,7 @@ describe LightService::Orchestrator do
   it 'does not iterate over a skipped context' do
     empty_context.skip_remaining!('No more needed')
 
-    result = TestIterate.run(empty_context)
+    result = OrchestratorTestIterate.run(empty_context)
     expect(result).to be_success
   end
 end

data/spec/acceptance/orchestrator/organizer_action_combination_spec.rb

@@ -2,7 +2,9 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe LightService::Orchestrator do
-  class TestReduce
+  include_context 'expect orchestrator warning'
+
+  class OrchestratorTestReduce
     extend LightService::Orchestrator
 
     def self.run(context, steps)
@@ -11,21 +13,21 @@ describe LightService::Orchestrator do
   end
 
   it 'responds to both actions and organizers' do
-    result = TestReduce.run({ :number => 0 }, [
-                              TestDoubles::AddTwoOrganizer,
-                              TestDoubles::AddOneAction
-                            ])
+    result = OrchestratorTestReduce.run({ :number => 0 }, [
+                                          TestDoubles::AddTwoOrganizer,
+                                          TestDoubles::AddsOneAction
+                                        ])
 
     expect(result).to be_success
     expect(result.number).to eq(3)
   end
 
   it 'fails fast by skipping proceeding actions/organizers after failure' do
-    result = TestReduce.run({ :number => 0 }, [
-                              TestDoubles::AddTwoOrganizer,
-                              TestDoubles::FailureAction,
-                              TestDoubles::AddOneAction
-                            ])
+    result = OrchestratorTestReduce.run({ :number => 0 }, [
+                                          TestDoubles::AddTwoOrganizer,
+                                          TestDoubles::FailureAction,
+                                          TestDoubles::AddsOneAction
+                                        ])
 
     expect(result).not_to be_success
     expect(result.number).to eq(2)
@@ -33,7 +35,7 @@ describe LightService::Orchestrator do
 
   it 'does not allow anything but actions and organizers' do
     expect do
-      TestReduce.run({}, [double])
+      OrchestratorTestReduce.run({}, [double])
     end.to raise_error(RuntimeError)
   end
 end

data/spec/acceptance/orchestrator/reduce_if_spec.rb

@@ -2,7 +2,9 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe LightService::Orchestrator do
-  class TestReduceIf
+  include_context 'expect orchestrator warning'
+
+  class OrchestratorTestReduceIf
     extend LightService::Orchestrator
 
     def self.run(context)
@@ -11,9 +13,9 @@ describe LightService::Orchestrator do
 
     def self.steps
       [
-        TestDoubles::AddOneAction,
+        TestDoubles::AddsOneAction,
         reduce_if(->(ctx) { ctx.number == 1 },
-                  TestDoubles::AddOneAction)
+                  TestDoubles::AddsOneAction)
       ]
     end
   end
@@ -21,14 +23,14 @@ describe LightService::Orchestrator do
   let(:empty_context) { LightService::Context.make }
 
   it 'reduces if the block evaluates to true' do
-    result = TestReduceIf.run(:number => 0)
+    result = OrchestratorTestReduceIf.run(:number => 0)
 
     expect(result).to be_success
     expect(result[:number]).to eq(2)
   end
 
   it 'does not reduce if the block evaluates to false' do
-    result = TestReduceIf.run(:number => 2)
+    result = OrchestratorTestReduceIf.run(:number => 2)
 
     expect(result).to be_success
     expect(result[:number]).to eq(3)
@@ -37,7 +39,7 @@ describe LightService::Orchestrator do
   it 'will not reduce over a failed context' do
     empty_context.fail!('Something bad happened')
 
-    result = TestReduceIf.run(empty_context)
+    result = OrchestratorTestReduceIf.run(empty_context)
 
     expect(result).to be_failure
   end
@@ -45,7 +47,7 @@ describe LightService::Orchestrator do
   it 'does not reduce over a skipped context' do
     empty_context.skip_remaining!('No more needed')
 
-    result = TestReduceIf.run(empty_context)
+    result = OrchestratorTestReduceIf.run(empty_context)
     expect(result).to be_success
   end
 end

data/spec/acceptance/orchestrator/reduce_until_spec.rb

@@ -2,7 +2,9 @@ require 'spec_helper'
 require 'test_doubles'
 
 RSpec.describe LightService::Orchestrator do
-  class TestReduceUntil
+  include_context 'expect orchestrator warning'
+
+  class OrchestratorTestReduceUntil
     extend LightService::Orchestrator
 
     def self.run(context)
@@ -12,7 +14,7 @@ RSpec.describe LightService::Orchestrator do
     def self.steps
       [
         reduce_until(->(ctx) { ctx.number == 3 },
-                     TestDoubles::AddOneAction)
+                     TestDoubles::AddsOneAction)
       ]
     end
   end
@@ -21,7 +23,7 @@ RSpec.describe LightService::Orchestrator do
 
   it 'reduces until the block evaluates to true' do
     context = { :number => 1 }
-    result = TestReduceUntil.run(context)
+    result = OrchestratorTestReduceUntil.run(context)
 
     expect(result).to be_success
     expect(result.number).to eq(3)
@@ -30,14 +32,14 @@ RSpec.describe LightService::Orchestrator do
   it 'does not execute on failed context' do
     empty_context.fail!('Something bad happened')
 
-    result = TestReduceUntil.run(empty_context)
+    result = OrchestratorTestReduceUntil.run(empty_context)
     expect(result).to be_failure
   end
 
   it 'does not execute a skipped context' do
     empty_context.skip_remaining!('No more needed')
 
-    result = TestReduceUntil.run(empty_context)
+    result = OrchestratorTestReduceUntil.run(empty_context)
     expect(result).to be_success
   end
 end

data/spec/acceptance/orchestrator/with_callback_spec.rb

@@ -2,7 +2,9 @@ require 'spec_helper'
 require 'test_doubles'
 
 describe LightService::Orchestrator do
-  class TestWithCallback
+  include_context 'expect orchestrator warning'
+
+  class OrchestratorTestWithCallback
     extend LightService::Orchestrator
 
     def self.run(context = {})
@@ -63,7 +65,7 @@ describe LightService::Orchestrator do
 
   describe 'a simple case with a single callback' do
     it 'calls the actions defined with callback' do
-      result = TestWithCallback.run
+      result = OrchestratorTestWithCallback.run
 
       expect(result.counter).to eq(3)
       expect(result.total).to eq(6)
@@ -71,7 +73,7 @@ describe LightService::Orchestrator do
   end
 
   describe 'a more complex example with nested callbacks' do
-    class TestWithNestedCallback
+    class OrchestratorTestWithNextedCallback
       extend LightService::Orchestrator
 
       def self.run(context = {})
@@ -127,7 +129,7 @@ describe LightService::Orchestrator do
     end
 
     it 'calls both the action and the nested callbacks' do
-      result = TestWithNestedCallback.run
+      result = OrchestratorTestWithNextedCallback.run
 
       expect(result.outer_counter).to eq(2)
       # Counts and total are the duplicates of
@@ -141,7 +143,7 @@ describe LightService::Orchestrator do
   end
 
   describe 'with failed or skipped context' do
-    class TestWithFailureCallback
+    class OrchestratorTestWithFailureCallback
       extend LightService::Orchestrator
 
       def self.run(context = {})
@@ -159,7 +161,7 @@ describe LightService::Orchestrator do
     end
 
     it 'will not process the routine' do
-      result = TestWithFailureCallback.run
+      result = OrchestratorTestWithFailureCallback.run
 
       expect(result).to be_failure
       expect(result.counter).to eq(1)

data/spec/acceptance/organizer/around_each_with_reduce_if_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  class TestReduceIfWithAroundEach
+    extend LightService::Organizer
+
+    def self.call(context)
+      with(context)
+        .around_each(TestDoubles::AroundEachLoggerHandler)
+        .reduce(actions)
+    end
+
+    def self.actions
+      [
+        TestDoubles::AddsOneAction,
+        reduce_if(->(ctx) { ctx.number == 1 },
+                  TestDoubles::AddsOneAction)
+      ]
+    end
+  end
+
+  it 'can be used to log data' do
+    result =
+      TestReduceIfWithAroundEach
+      .call(:number => 0,
+            :logger => TestDoubles::TestLogger.new)
+
+    expect(result.fetch(:number)).to eq(2)
+    expect(result[:logger].logs).to eq(
+      [{
+        :action => TestDoubles::AddsOneAction,
+        :before => 0,
+        :after => 1
+      }, {
+        :action => TestDoubles::AddsOneAction,
+        :before => 1,
+        :after => 2
+      }]
+    )
+  end
+end

data/spec/acceptance/organizer/context_failure_and_skipping_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Organizer do
+  class TestSkipBefore
+    extend LightService::Organizer
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  TestDoubles::SkipAllAction,
+                  reduce_until(->(ctx) { ctx.number == 3 },
+                               TestDoubles::AddsOneAction)
+                ])
+    end
+  end
+
+  class TestSkipAfter
+    extend LightService::Organizer
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  TestDoubles::AddsOneAction,
+                  reduce_until(->(ctx) { ctx.number == 3 }, [
+                                 TestDoubles::AddsOneAction
+                               ]),
+                  TestDoubles::SkipAllAction,
+                  TestDoubles::AddsOneAction
+                ])
+    end
+  end
+
+  class TestContextFailure
+    extend LightService::Organizer
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  TestDoubles::FailureAction,
+                  reduce_until(->(ctx) { ctx[:number] == 3 },
+                               TestDoubles::AddsOneAction),
+                  TestDoubles::AddsOneAction
+                ])
+    end
+  end
+
+  it 'skips all the rest of the actions' do
+    result = TestSkipBefore.call
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(1)
+  end
+
+  it 'skips after an action in nested context' do
+    result = TestSkipAfter.call
+
+    expect(result).to be_success
+    expect(result[:number]).to eq(3)
+  end
+
+  it 'respects failure across all nestings' do
+    result = TestContextFailure.call
+
+    expect(result).to be_failure
+    expect(result[:number]).to eq(1)
+  end
+end