light-service 0.8.4 → 0.9.0

data/lib/light-service/organizer/with_reducer_factory.rb

@@ -3,7 +3,9 @@ module LightService
     class WithReducerFactory
       def self.make(monitored_organizer)
         if LightService::Configuration.logger.nil?
+          # :nocov:
           WithReducer.new
+          # :nocov:
         else
           WithReducerLogDecorator.new(monitored_organizer, WithReducer.new)
         end

data/lib/light-service/version.rb

@@ -1,3 +1,3 @@
 module LightService
-  VERSION = "0.8.4".freeze
+  VERSION = "0.9.0".freeze
 end

data/light-service.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency("activesupport", ">= 3.0")
 
   gem.add_development_dependency("rspec", "~> 3.0")
-  gem.add_development_dependency("simplecov", "~> 0.14.1")
+  gem.add_development_dependency("simplecov", "~> 0.15.1")
   gem.add_development_dependency("rubocop", "~> 0.51")
   gem.add_development_dependency("pry", "~> 0.10")
 end

data/resources/orchestrators_deprecated.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" 
+     xmlns="http://www.w3.org/2000/svg"
+     xmlns:xlink="http://www.w3.org/1999/xlink"
+     width="350" height="20"
+>
+  <text font-size="20" x="0" y="20" font-family="Verdana">
+    <tspan fill="red">Orchestrators are DEPRECATED!</tspan>
+  </text>
+</svg>

data/spec/acceptance/orchestrator/context_failure_and_skipping_spec.rb

@@ -2,7 +2,9 @@ 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([
@@ -34,21 +36,21 @@ describe LightService::Orchestrator do
   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)
@@ -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,7 +2,9 @@ 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)
@@ -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::AddOneAction
+                                        ])
 
     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::AddOneAction
+                                        ])
 
     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)
@@ -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)
@@ -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::AddOneAction,
+        reduce_if(->(ctx) { ctx.number == 1 },
+                  TestDoubles::AddOneAction)
+      ]
+    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::AddOneAction,
+        :before => 0,
+        :after => 1
+      }, {
+        :action => TestDoubles::AddOneAction,
+        :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::AddOneAction)
+                ])
+    end
+  end
+
+  class TestSkipAfter
+    extend LightService::Organizer
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  TestDoubles::AddOneAction,
+                  reduce_until(->(ctx) { ctx.number == 3 }, [
+                                 TestDoubles::AddOneAction
+                               ]),
+                  TestDoubles::SkipAllAction,
+                  TestDoubles::AddOneAction
+                ])
+    end
+  end
+
+  class TestContextFailure
+    extend LightService::Organizer
+    def self.call
+      with(:number => 1)
+        .reduce([
+                  TestDoubles::FailureAction,
+                  reduce_until(->(ctx) { ctx[:number] == 3 },
+                               TestDoubles::AddOneAction),
+                  TestDoubles::AddOneAction
+                ])
+    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